create-pmos 0.134.0 → 0.136.0

package/workspace/lib/report-schedules.js

@@ -0,0 +1,113 @@
+'use strict';
+/* report-schedules.js — a schedule per Reports dashboard: a ready draft in the outbox on each run, and a notice on the bell
+ * (initiative console3-dashboard-schedules, PRD R1 to R4). NOTHING IS SENT: a run only appends one outbox draft.
+ *
+ *   PLANS                                        weekly (Mondays 08:00) and monthly (the 1st at 08:00), host-local, as lib/schedule-logic.js reads them
+ *   readSchedules(runtimeDir)                    → { [key]: { key, ws, plan, audience, lastRun, last_status, last_error, last_draft, created_at } }
+ *   viewOf(schedules, now)                       → the same, each with label and next_run (ISO), for GET /api/report-dashboards
+ *   saveSchedule(runtimeDir, body, now)          { key, plan: none|weekly|monthly, audience, ws } → { ok, schedules } | { ok:false, error }
+ *   dueOf(schedules, now)                        → the schedules with a slot in (lastRun, now]
+ *   markRun(runtimeDir, key, fields)             merges the run's outcome into the schedule
+ *   makeDraft(runtimeDir, sched, frame, now)     → the outbox entry: ONE 'queued' line, made_by 'schedule'
+ *   noticesOf(entries, now)                      → the bell's notices: scheduled drafts of the last 7 days still in the outbox
+ *
+ * The store is <runtimeDir>/report-dashboards/schedules.json, written with a temp file and a rename, beside layouts.json. Saving a
+ * schedule sets lastRun to now, so a slot that is already past never runs on save. schedule-logic.isDue fires once for the newest
+ * slot in (lastRun, now], so slots missed while the server was down are not caught up one by one. */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const logic = require('./schedule-logic.js');
+const rd = require('./report-dashboards.js');
+const { repoScript } = require('./repo-script.js');
+const outbox = require(repoScript('outbox.js'));
+const store = require('./outbox-store.js');
+
+const PLANS = Object.freeze({
+  weekly: Object.freeze({ cadence: 'weekly', day: 'Mon', time: '08:00', label: 'Weekly, Mondays 08:00' }),
+  monthly: Object.freeze({ cadence: 'monthly', dayOfMonth: 1, time: '08:00', label: 'Monthly, 1st at 08:00' }),
+});
+const AUDIENCES = ['Leadership', 'Team'];
+const NOTICE_MS = 7 * 864e5;
+
+const dirOf = (runtimeDir) => path.join(runtimeDir, 'report-dashboards');
+const fileOf = (runtimeDir) => path.join(dirOf(runtimeDir), 'schedules.json');
+const timing = (s) => ({ ...PLANS[s.plan], enabled: true, lastRun: s.lastRun || null });
+
+/** A missing or damaged file reads as no schedules; an entry that is not valid is dropped. */
+function readSchedules(runtimeDir) {
+  let raw;
+  try { raw = JSON.parse(fs.readFileSync(fileOf(runtimeDir), 'utf8')); } catch { return {}; }
+  const src = raw && typeof raw === 'object' && raw.schedules && typeof raw.schedules === 'object' ? raw.schedules : {};
+  const out = {};
+  for (const [k, v] of Object.entries(src)) {
+    if (!rd.validKey(k) || !v || !PLANS[v.plan] || !AUDIENCES.includes(v.audience)) continue;
+    out[k] = { ...v, key: k };
+  }
+  return out;
+}
+
+function writeAll(runtimeDir, schedules) {
+  const dir = dirOf(runtimeDir);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmp = path.join(dir, 'schedules.json.' + process.pid + '.' + crypto.randomBytes(4).toString('hex') + '.tmp');
+  try {
+    fs.writeFileSync(tmp, JSON.stringify({ schedules }, null, 2) + '\n');
+    fs.renameSync(tmp, fileOf(runtimeDir));
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch { /* nothing to remove */ }
+    return { ok: false, error: 'the schedule could not be saved: ' + String((e && e.message) || e) };
+  }
+  return { ok: true, schedules };
+}
+
+function viewOf(schedules, now = new Date()) {
+  const out = {};
+  for (const [k, s] of Object.entries(schedules || {})) out[k] = { ...s, label: PLANS[s.plan].label, next_run: logic.nextRun(timing(s), now) };
+  return out;
+}
+
+function saveSchedule(runtimeDir, body, now = new Date()) {
+  if (!runtimeDir || typeof runtimeDir !== 'string') return { ok: false, error: 'no runtime directory' };
+  const b = body || {};
+  if (!rd.validKey(b.key)) return { ok: false, error: 'key must be portfolio, board:<id> or initiative:<id>' };
+  if (b.plan !== 'none' && !PLANS[b.plan]) return { ok: false, error: 'plan must be none, weekly or monthly' };
+  if (b.plan !== 'none' && !AUDIENCES.includes(b.audience)) return { ok: false, error: 'audience must be Leadership or Team' };
+  if (b.ws != null && (typeof b.ws !== 'string' || b.ws.length > 200)) return { ok: false, error: 'ws must be a workspace id' };
+  const all = readSchedules(runtimeDir);
+  if (b.plan === 'none') delete all[b.key];
+  else {
+    const cur = all[b.key];
+    const same = cur && cur.plan === b.plan;
+    all[b.key] = { key: b.key, ws: b.ws || null, plan: b.plan, audience: b.audience, created_at: (cur && cur.created_at) || now.toISOString(),
+      lastRun: same ? cur.lastRun : now.toISOString(), last_status: same ? cur.last_status || null : null, last_error: same ? cur.last_error || null : null, last_draft: same ? cur.last_draft || null : null };
+  }
+  return writeAll(runtimeDir, all);
+}
+
+const dueOf = (schedules, now = new Date()) => Object.values(schedules || {}).filter((s) => logic.isDue(timing(s), now));
+
+function markRun(runtimeDir, key, fields) {
+  const all = readSchedules(runtimeDir);
+  if (!all[key]) return { ok: false, error: 'no schedule for ' + key };
+  all[key] = { ...all[key], ...fields, key };
+  return writeAll(runtimeDir, all);
+}
+
+/** One draft for the schedule, from the frame lib/report-frame.js built. The hash covers what the outbox hashes; made_by and schedule_key ride beside it. */
+function makeDraft(runtimeDir, sched, F, body, now = new Date()) {
+  const e = outbox.draftOutbox({ channel: 'customer-note', recipient: F.audience, subject: F.title + ' for ' + F.audience, body, origin: 'pm' });
+  const entry = { id: 'out-' + crypto.randomBytes(6).toString('hex'), ...e, made_by: 'schedule', schedule_key: sched.key };
+  store.appendEvent(runtimeDir, { event: 'queued', ...entry }, now);
+  return entry;
+}
+
+function noticesOf(entries, now = new Date()) {
+  const t = now.getTime();
+  return (entries || []).filter((e) => e && e.made_by === 'schedule' && e.state !== 'sent' && t - Date.parse(e.created_at || 0) <= NOTICE_MS)
+    .sort((a, b) => String(b.created_at).localeCompare(String(a.created_at)))
+    .map((e) => ({ key: 'dash-draft:' + e.id, tag: 'Just in', icon: 'mail', headline: (e.subject || 'A dashboard') + ': a scheduled draft is ready. Nothing was sent.',
+      when: '', unread: true, go: { tab: 'rep', view: 'drafts' } }));
+}
+
+module.exports = { PLANS, AUDIENCES, readSchedules, viewOf, saveSchedule, dueOf, markRun, makeDraft, noticesOf, fileOf };

package/workspace/lib/route-modules.js

@@ -16,7 +16,8 @@
  *   };
  * `ctx` is what server.js hands over, plus `readJson`:
  *   { json(res, obj, code), readBody(req), readJson(req) → { ok, body } | { ok: false },
- *     getWs(id), invalidateNeedsAgg(id), boardCache, consoleState, stateDirFor(w), sessionList() }
+ *     getWs(id), invalidateNeedsAgg(id), boardCache, consoleState, stateDirFor(w), sessionList(), runtimeDir,
+ *     workspaceList(), selfRoot (the embedded PMOS checkout, or null), … }
  * A module needs nothing else from server.js; it requires the lib/ modules it uses itself (spelled with `.js` when the
  * module is a ledger writer, so scripts/check-separation.js lists the caller).
  *
@@ -61,8 +62,11 @@ const MODULES = Object.freeze([
   'routes-c3-strategy',   // console3 Calendar Quarter and Year panes: outcomes, north star, signals, synergy, bets (read-only)
   'routes-c3-reports',    // console3 Reports dashboards: library, per-scope data, page-press layouts (layouts are the only write)
   'routes-onboarding',    // onboarding-scan-and-map slice 2: first run (scan read-only, structure, import into the overlay, undo, first Briefing)
+  'routes-boards',        // c3-initiative-boards: Portfolio, Board, Backlog, Triage asks, workflows and moves (boards.jsonl)
+  'routes-settings',      // console3 Settings: the settings store for settings with no home of their own (GET; page-press POST)
   'routes-hooks',         // planning-flows run 7: CLI hook endpoints (session token, per-run JSONL)
   'routes-sources',       // workspace-data-freshness: how old each source is, Refresh now, the change detector switch
+  'routes-stage-tools',   // stage-tools-records: the records the PM edits per stage, what PMOS holds per stage, the sprint burndown
 ]);
 const PM_DIR = path.join(__dirname, '..', 'public', 'pm');
 const MODULE_NAME = /^[a-z0-9][a-z0-9-]*\.js$/;
@@ -79,7 +83,10 @@ function load() {
     let mod;
     try { mod = require(full); }
     catch (e) {
-      if (e && e.code === 'MODULE_NOT_FOUND' && String(e.message).includes(full)) continue;   // not built yet
+      // Not built yet only when the module ITSELF is missing. Node lists the requiring file in the message too ("Require
+      // stack: - <full>"), so a module whose own require fails used to match here and vanish as "not built": in a package
+      // that left 21 route modules unrouted with no broken entry (incident workspace-package-script-closure).
+      if (e && e.code === 'MODULE_NOT_FOUND' && String(e.message).split('\n')[0].includes(full)) continue;
       broken[name] = `${name}.js failed to load: ${String((e && e.message) || e).slice(0, 200)}`;
       continue;
     }