buddy-workbench 0.1.109 → 0.1.111

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.1.109",
+  "version": "0.1.111",
   "private": false,
   "type": "module",
   "bin": {

package/server/config.js

@@ -29,6 +29,8 @@ export const paths = {
   jiraTemplates: join(userDataDir, 'jira-templates.json'),
   jiraRecentlyCreated: join(userDataDir, 'jira-recently-created.json'),
   todos: join(userDataDir, 'todos.json'),
+  reminders: join(userDataDir, 'reminders.json'),
+  cronJobs: join(userDataDir, 'cron-jobs.json'),
   memos: join(userDataDir, 'memos.json'),
   memoImages: join(userDataDir, 'memo-images'),
   staticPages: join(userDataDir, 'static-pages.json'),

package/server/repositories/cron-jobs.js

@@ -0,0 +1,16 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { paths } from '../config.js';
+
+export function listCronJobs() {
+  try {
+    return existsSync(paths.cronJobs) ? JSON.parse(readFileSync(paths.cronJobs, 'utf8')) : [];
+  } catch {
+    return [];
+  }
+}
+
+export function saveCronJobs(jobs) {
+  mkdirSync(dirname(paths.cronJobs), { recursive: true });
+  writeFileSync(paths.cronJobs, JSON.stringify(jobs, null, 2));
+}

package/server/repositories/reminders.js

@@ -0,0 +1,16 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { paths } from '../config.js';
+
+export function listReminders() {
+  try {
+    return existsSync(paths.reminders) ? JSON.parse(readFileSync(paths.reminders, 'utf8')) : [];
+  } catch {
+    return [];
+  }
+}
+
+export function saveReminders(reminders) {
+  mkdirSync(dirname(paths.reminders), { recursive: true });
+  writeFileSync(paths.reminders, JSON.stringify(reminders, null, 2));
+}

package/server/routes/cron-jobs.js

@@ -0,0 +1,157 @@
+import { existsSync, statSync } from 'node:fs';
+import { Router } from 'express';
+import { listCronJobs, saveCronJobs } from '../repositories/cron-jobs.js';
+import { listGroupTasks } from '../repositories/group-tasks.js';
+import { listLaunchers } from '../repositories/launchers.js';
+import { readPackageScripts } from '../services/package-scripts.js';
+import { executeCronJob, nextCronJobRun } from '../services/cron-jobs.js';
+
+const router = Router();
+const SCHEDULE_TYPES = ['once', 'daily', 'weekdays', 'weekly', 'cron'];
+const TARGET_TYPES = ['custom', 'quick-launch', 'launcher-script'];
+
+function validTime(value) {
+  const time = String(value || '').trim();
+  return /^([01]\d|2[0-3]):[0-5]\d$/.test(time) ? time : null;
+}
+
+function validCronExpression(value) {
+  const expression = String(value || '').trim();
+  return expression && expression.split(/\s+/).length === 5 ? expression : null;
+}
+
+function normalizeTarget(body) {
+  const targetType = TARGET_TYPES.includes(body?.targetType) ? body.targetType : 'custom';
+  const args = String(body?.args || '').trim().slice(0, 1000);
+  if (targetType === 'custom') {
+    const command = String(body?.command || '').trim().slice(0, 2000);
+    const workingDirectory = String(body?.workingDirectory || '').trim();
+    if (!command || !workingDirectory) return { error: 'A command and working directory are required.' };
+    if (!existsSync(workingDirectory) || !statSync(workingDirectory).isDirectory()) return { error: 'The custom script working directory must be an existing folder.' };
+    return { value: { targetType, command, args, workingDirectory } };
+  }
+  if (targetType === 'quick-launch') {
+    const quickLaunchId = String(body?.quickLaunchId || '').trim();
+    if (!quickLaunchId) return { error: 'Choose a Quick Launch.' };
+    if (!listGroupTasks().some((task) => task.id === quickLaunchId)) return { error: 'The selected Quick Launch does not exist.' };
+    return { value: { targetType, args, quickLaunchId } };
+  }
+  const launcherId = String(body?.launcherId || '').trim();
+  const scriptId = String(body?.scriptId || '').trim();
+  const launcher = listLaunchers().find((item) => item.id === launcherId);
+  if (!launcher) return { error: 'Choose a valid Launcher.' };
+  const scripts = [...launcher.scripts, ...readPackageScripts(launcher.folder)];
+  if (!scripts.some((script) => script.id === scriptId)) return { error: 'Choose a valid Launcher script.' };
+  return { value: { targetType, args, launcherId, scriptId } };
+}
+
+function normalizeSchedule(body, now = new Date()) {
+  const scheduleType = SCHEDULE_TYPES.includes(body?.scheduleType) ? body.scheduleType : 'daily';
+  const enabled = body?.enabled !== false;
+  const value = { scheduleType, time: null, weekday: null, scheduledAt: null, cronExpression: null };
+  if (scheduleType === 'once') {
+    const scheduledAt = new Date(body?.scheduledAt);
+    scheduledAt.setSeconds(0, 0);
+    if (Number.isNaN(scheduledAt.getTime()) || (enabled && scheduledAt <= now)) return { error: 'Choose a future date and time.' };
+    value.scheduledAt = scheduledAt.toISOString();
+  } else if (scheduleType === 'cron') {
+    value.cronExpression = validCronExpression(body?.cronExpression);
+    if (!value.cronExpression) return { error: 'Enter a valid five-field cron expression.' };
+  } else {
+    value.time = validTime(body?.time);
+    if (!value.time) return { error: 'Choose a valid time.' };
+    if (scheduleType === 'weekly') {
+      value.weekday = Number(body?.weekday);
+      if (!Number.isInteger(value.weekday) || value.weekday < 0 || value.weekday > 6) return { error: 'Choose a weekday.' };
+    }
+  }
+  value.nextRunAt = enabled ? nextCronJobRun(value, now) : null;
+  if (enabled && !value.nextRunAt) return { error: 'Unable to calculate the next run time.' };
+  return { value };
+}
+
+function normalizeJob(body, now = new Date()) {
+  const name = String(body?.name || '').trim().slice(0, 50);
+  if (!name) return { error: 'Cron Job name is required.' };
+  const target = normalizeTarget(body);
+  if (target.error) return target;
+  const schedule = normalizeSchedule(body, now);
+  if (schedule.error) return schedule;
+  return { value: { name, enabled: body?.enabled !== false, ...target.value, ...schedule.value } };
+}
+
+router.get('/', (_req, res) => {
+  res.json(listCronJobs().sort((a, b) => Number(b.enabled) - Number(a.enabled) || new Date(a.nextRunAt || 8640000000000000) - new Date(b.nextRunAt || 8640000000000000)));
+});
+
+router.get('/catalog', (_req, res) => {
+  const launchers = listLaunchers().map((launcher) => ({
+    id: launcher.id,
+    alias: launcher.alias,
+    folder: launcher.folder,
+    scripts: [...launcher.scripts.map((script) => ({ id: script.id, name: script.name, source: 'Custom' })), ...readPackageScripts(launcher.folder).map((script) => ({ id: script.id, name: script.name, source: 'Package' }))]
+  }));
+  const quickLaunches = listGroupTasks().map((task) => ({ id: task.id, name: task.name, scriptCount: task.items.length }));
+  res.json({ launchers, quickLaunches });
+});
+
+router.post('/', (req, res) => {
+  const normalized = normalizeJob(req.body);
+  if (normalized.error) return res.status(400).json({ error: normalized.error });
+  const now = new Date().toISOString();
+  const job = { id: crypto.randomUUID(), ...normalized.value, createdAt: now, updatedAt: now, lastRunAt: null, lastStatus: null, lastError: '' };
+  const jobs = listCronJobs();
+  jobs.push(job);
+  saveCronJobs(jobs);
+  res.status(201).json(job);
+});
+
+router.put('/:id', (req, res) => {
+  const jobs = listCronJobs();
+  const index = jobs.findIndex((item) => item.id === req.params.id);
+  if (index < 0) return res.status(404).json({ error: 'Cron Job not found.' });
+  const normalized = normalizeJob(req.body);
+  if (normalized.error) return res.status(400).json({ error: normalized.error });
+  const updated = { ...jobs[index], ...normalized.value, updatedAt: new Date().toISOString() };
+  jobs[index] = updated;
+  saveCronJobs(jobs);
+  res.json(updated);
+});
+
+router.post('/:id/toggle', (req, res) => {
+  const jobs = listCronJobs();
+  const index = jobs.findIndex((item) => item.id === req.params.id);
+  if (index < 0) return res.status(404).json({ error: 'Cron Job not found.' });
+  const job = jobs[index];
+  const enabled = req.body?.enabled !== undefined ? Boolean(req.body.enabled) : !job.enabled;
+  if (enabled) {
+    const nextRunAt = nextCronJobRun(job, new Date());
+    if (!nextRunAt || (job.scheduleType === 'once' && new Date(nextRunAt) <= new Date())) return res.status(400).json({ error: 'Edit this Cron Job to choose a future run time.' });
+    job.nextRunAt = nextRunAt;
+  } else {
+    job.nextRunAt = null;
+  }
+  job.enabled = enabled;
+  job.updatedAt = new Date().toISOString();
+  jobs[index] = job;
+  saveCronJobs(jobs);
+  res.json(job);
+});
+
+router.post('/:id/run', (req, res) => {
+  try {
+    res.json(executeCronJob(req.params.id));
+  } catch (error) {
+    res.status(error.message.includes('already running') ? 409 : 400).json({ error: error.message });
+  }
+});
+
+router.delete('/:id', (req, res) => {
+  const jobs = listCronJobs();
+  const next = jobs.filter((item) => item.id !== req.params.id);
+  if (next.length === jobs.length) return res.status(404).json({ error: 'Cron Job not found.' });
+  saveCronJobs(next);
+  res.status(204).end();
+});
+
+export default router;

package/server/routes/group-tasks.js

@@ -11,6 +11,19 @@ router.get('/', (_req, res) => res.json(listGroupTasks()));
 router.get('/catalog', (_req, res) => res.json(listLaunchers().map((launcher) => ({ id: launcher.id, alias: launcher.alias, groupName: launcher.groupName || 'Ungrouped', scripts: [...launcher.scripts.map((script) => ({ id: script.id, name: script.name, source: 'Custom' })), ...readPackageScripts(launcher.folder).map((script) => ({ id: script.id, name: script.name, source: 'Package' }))] }))));
 router.post('/', (req, res) => { const task = validTask(req.body); if (!task) return res.status(400).json({ error: 'A name and at least one script are required.' }); const created = { id: crypto.randomUUID(), ...task }; saveGroupTasks([...listGroupTasks(), created]); res.status(201).json(created); });
 router.put('/:id', (req, res) => { const task = validTask(req.body); if (!task) return res.status(400).json({ error: 'A name and at least one script are required.' }); const tasks = listGroupTasks(); const index = tasks.findIndex((item) => item.id === req.params.id); if (index < 0) return res.status(404).json({ error: 'Group task not found.' }); const updated = { id: req.params.id, ...task }; tasks[index] = updated; saveGroupTasks(tasks); res.json(updated); });
+router.post('/:id/move', (req, res) => {
+  const direction = req.body?.direction;
+  if (direction !== 'up' && direction !== 'down') return res.status(400).json({ error: 'A move direction is required.' });
+  const tasks = listGroupTasks();
+  const index = tasks.findIndex((item) => item.id === req.params.id);
+  if (index < 0) return res.status(404).json({ error: 'Group task not found.' });
+  const targetIndex = direction === 'up' ? index - 1 : index + 1;
+  if (targetIndex >= 0 && targetIndex < tasks.length) {
+    [tasks[index], tasks[targetIndex]] = [tasks[targetIndex], tasks[index]];
+    saveGroupTasks(tasks);
+  }
+  res.json(tasks);
+});
 router.delete('/:id', (req, res) => { const tasks = listGroupTasks(); const next = tasks.filter((item) => item.id !== req.params.id); if (next.length === tasks.length) return res.status(404).json({ error: 'Group task not found.' }); saveGroupTasks(next); res.status(204).end(); });
 router.post('/:id/start', (req, res) => { const task = listGroupTasks().find((item) => item.id === req.params.id); if (!task) return res.status(404).json({ error: 'Group task not found.' }); const launchers = listLaunchers(); const results = task.items.map((item) => { const launcher = launchers.find((entry) => entry.id === item.launcherId); if (!launcher) return { ...item, error: 'Service not found.' }; const custom = launcher.scripts.find((script) => script.id === item.scriptId); const packageScript = custom ? null : readPackageScripts(launcher.folder).find((script) => script.id === item.scriptId); if (!custom && !packageScript) return { ...item, error: 'Script not found.' }; try { runScript(launcher, custom || { ...packageScript, command: `${launcher.executor} run ${packageScript.name}` }); return { ...item, ok: true }; } catch (error) { return { ...item, error: error.message }; } }); res.json({ results }); });
 router.post('/:id/stop', (req, res) => { const task = listGroupTasks().find((item) => item.id === req.params.id); if (!task) return res.status(404).json({ error: 'Group task not found.' }); const results = task.items.map((item) => { try { stopScript(item.launcherId, item.scriptId); return { ...item, ok: true }; } catch (error) { return { ...item, error: error.message }; } }); res.json({ results }); });

package/server/routes/reminders.js

@@ -0,0 +1,167 @@
+import { Router } from 'express';
+import { listReminders, saveReminders } from '../repositories/reminders.js';
+
+const router = Router();
+const SCHEDULE_TYPES = ['once', 'daily', 'weekdays', 'weekly'];
+
+function validTime(value) {
+  const time = String(value || '').trim();
+  if (!/^([01]\d|2[0-3]):[0-5]\d$/.test(time)) return null;
+  return time;
+}
+
+function setLocalTime(date, time) {
+  const [hours, minutes] = time.split(':').map(Number);
+  const next = new Date(date);
+  next.setHours(hours, minutes, 0, 0);
+  return next;
+}
+
+function nextRepeatingRun(reminder, now = new Date()) {
+  const time = validTime(reminder.time);
+  if (!time) return null;
+  const candidate = setLocalTime(now, time);
+
+  if (reminder.scheduleType === 'daily') {
+    if (candidate <= now) candidate.setDate(candidate.getDate() + 1);
+    return candidate.toISOString();
+  }
+
+  if (reminder.scheduleType === 'weekdays') {
+    if (candidate <= now) candidate.setDate(candidate.getDate() + 1);
+    while ([0, 6].includes(candidate.getDay())) candidate.setDate(candidate.getDate() + 1);
+    return candidate.toISOString();
+  }
+
+  const weekday = Number(reminder.weekday);
+  if (!Number.isInteger(weekday) || weekday < 0 || weekday > 6) return null;
+  let daysAhead = (weekday - candidate.getDay() + 7) % 7;
+  if (daysAhead === 0 && candidate <= now) daysAhead = 7;
+  candidate.setDate(candidate.getDate() + daysAhead);
+  return candidate.toISOString();
+}
+
+function normalizeReminder(body, now = new Date()) {
+  const title = String(body?.title || '').trim().slice(0, 50);
+  const content = String(body?.content || '').trim().slice(0, 100);
+  const scheduleType = SCHEDULE_TYPES.includes(body?.scheduleType) ? body.scheduleType : 'once';
+  if (!title) return { error: 'Reminder title is required.' };
+  if (!content) return { error: 'Notification content is required.' };
+
+  const normalized = {
+    title,
+    content,
+    scheduleType,
+    enabled: body?.enabled !== false,
+    time: null,
+    weekday: null,
+    scheduledAt: null
+  };
+
+  if (scheduleType === 'once') {
+    const scheduledAt = new Date(body?.scheduledAt);
+    if (Number.isNaN(scheduledAt.getTime())) return { error: 'Choose a valid reminder date and time.' };
+    scheduledAt.setSeconds(0, 0);
+    if (normalized.enabled && scheduledAt <= now) return { error: 'Reminder date and time must be in the future.' };
+    normalized.scheduledAt = scheduledAt.toISOString();
+    normalized.nextRunAt = normalized.enabled ? normalized.scheduledAt : null;
+    return { value: normalized };
+  }
+
+  normalized.time = validTime(body?.time);
+  if (!normalized.time) return { error: 'Choose a valid reminder time.' };
+  if (scheduleType === 'weekly') {
+    const weekday = Number(body?.weekday);
+    if (!Number.isInteger(weekday) || weekday < 0 || weekday > 6) return { error: 'Choose a weekday.' };
+    normalized.weekday = weekday;
+  }
+  normalized.nextRunAt = normalized.enabled ? nextRepeatingRun(normalized, now) : null;
+  if (!normalized.nextRunAt) return { error: 'Unable to calculate the next reminder time.' };
+  return { value: normalized };
+}
+
+router.get('/', (_req, res) => {
+  res.json(listReminders().sort((a, b) => {
+    if (a.enabled !== b.enabled) return a.enabled ? -1 : 1;
+    return new Date(a.nextRunAt || 8640000000000000) - new Date(b.nextRunAt || 8640000000000000);
+  }));
+});
+
+router.post('/claim-due', (req, res) => {
+  const now = new Date(req.body?.now || Date.now());
+  if (Number.isNaN(now.getTime())) return res.status(400).json({ error: 'Invalid current time.' });
+  const reminders = listReminders();
+  const due = [];
+  let changed = false;
+
+  reminders.forEach((reminder) => {
+    if (!reminder.enabled || !reminder.nextRunAt || new Date(reminder.nextRunAt) > now) return;
+    due.push({ id: reminder.id, title: reminder.title, content: reminder.content });
+    reminder.lastTriggeredAt = now.toISOString();
+    if (reminder.scheduleType === 'once') {
+      reminder.enabled = false;
+      reminder.nextRunAt = null;
+    } else {
+      reminder.nextRunAt = nextRepeatingRun(reminder, new Date(now.getTime() + 1000));
+    }
+    reminder.updatedAt = now.toISOString();
+    changed = true;
+  });
+
+  if (changed) saveReminders(reminders);
+  res.json({ due });
+});
+
+router.post('/', (req, res) => {
+  const normalized = normalizeReminder(req.body);
+  if (normalized.error) return res.status(400).json({ error: normalized.error });
+  const now = new Date().toISOString();
+  const reminder = { id: crypto.randomUUID(), ...normalized.value, createdAt: now, updatedAt: now };
+  const reminders = listReminders();
+  reminders.push(reminder);
+  saveReminders(reminders);
+  res.status(201).json(reminder);
+});
+
+router.put('/:id', (req, res) => {
+  const reminders = listReminders();
+  const index = reminders.findIndex((item) => item.id === req.params.id);
+  if (index < 0) return res.status(404).json({ error: 'Reminder not found.' });
+  const normalized = normalizeReminder(req.body);
+  if (normalized.error) return res.status(400).json({ error: normalized.error });
+  const now = new Date().toISOString();
+  const updated = { ...reminders[index], ...normalized.value, updatedAt: now };
+  reminders[index] = updated;
+  saveReminders(reminders);
+  res.json(updated);
+});
+
+router.post('/:id/toggle', (req, res) => {
+  const reminders = listReminders();
+  const index = reminders.findIndex((item) => item.id === req.params.id);
+  if (index < 0) return res.status(404).json({ error: 'Reminder not found.' });
+  const reminder = reminders[index];
+  const enabled = req.body?.enabled !== undefined ? Boolean(req.body.enabled) : !reminder.enabled;
+  const now = new Date();
+  if (enabled && reminder.scheduleType === 'once' && (!reminder.scheduledAt || new Date(reminder.scheduledAt) <= now)) {
+    return res.status(400).json({ error: 'This one-time reminder has passed. Edit its date before enabling it again.' });
+  }
+  reminder.enabled = enabled;
+  reminder.nextRunAt = enabled
+    ? (reminder.scheduleType === 'once' ? reminder.scheduledAt : nextRepeatingRun(reminder, now))
+    : null;
+  reminder.updatedAt = now.toISOString();
+  reminders[index] = reminder;
+  saveReminders(reminders);
+  res.json(reminder);
+});
+
+router.delete('/:id', (req, res) => {
+  const reminders = listReminders();
+  const next = reminders.filter((item) => item.id !== req.params.id);
+  if (next.length === reminders.length) return res.status(404).json({ error: 'Reminder not found.' });
+  saveReminders(next);
+  res.status(204).end();
+});
+
+export default router;