mover-os 4.7.7 → 4.7.8

package/src/dashboard/dashboard.js

@@ -0,0 +1,276 @@
+"use strict";
+
+(function () {
+  const REFRESH_INTERVAL = 30000;
+  const $ = (sel) => document.querySelector(sel);
+  const $$ = (sel) => Array.from(document.querySelectorAll(sel));
+
+  const els = {
+    refresh: $("#refresh-btn"),
+    modal: $("#modal"),
+    modalTitle: $("#modal-title"),
+    modalBody: $("#modal-body"),
+    modalClose: $("#modal-close"),
+    topbarDate: $("#topbar-date")
+  };
+
+  function tickClock() {
+    const now = new Date();
+    const time = `${pad(now.getHours())}:${pad(now.getMinutes())}`;
+    if (els.topbarDate) {
+      const text = els.topbarDate.textContent;
+      els.topbarDate.textContent = text.replace(/\b\d{2}:\d{2}\b/, time);
+    }
+  }
+  function pad(n) { return String(n).padStart(2, "0"); }
+
+  async function refresh() {
+    try {
+      flashRefresh();
+      const res = await fetch("/api/refresh", { cache: "no-cache" });
+      if (!res.ok) throw new Error("refresh failed");
+      window.location.reload();
+    } catch (e) {
+      flashError(e.message);
+    }
+  }
+
+  function flashRefresh() {
+    if (!els.refresh) return;
+    els.refresh.style.color = "var(--accent)";
+    els.refresh.style.borderColor = "var(--accent)";
+  }
+
+  function flashError(msg) {
+    if (!els.refresh) return;
+    const old = els.refresh.textContent;
+    els.refresh.textContent = "!";
+    els.refresh.style.borderColor = "#ff6464";
+    setTimeout(() => {
+      els.refresh.textContent = old;
+      els.refresh.style.borderColor = "";
+    }, 2000);
+  }
+
+  function openCommandModal(workflow, reason) {
+    if (!els.modal) return;
+    els.modalTitle.textContent = workflow === "Ask Mover" ? "Ask Mover" : "Run " + workflow;
+    const starterPrompt = workflow === "Ask Mover"
+      ? ""
+      : `Run ${workflow}. Explain why it was surfaced, what files you read, and what action changed.`;
+    els.modalBody.innerHTML = `
+      <div class="agent-runner">
+        <div class="agent-runner-reason">${escapeHtml(reason || "Use this as the command surface for the current brief.")}</div>
+        <div class="agent-controls">
+          <label class="mono">Agent
+            <select id="agent-select">
+              <option value="claude-code">Claude Code</option>
+              <option value="codex">Codex CLI</option>
+              <option value="gemini">Gemini CLI</option>
+            </select>
+          </label>
+          <label class="mono">Task
+            <textarea id="agent-prompt" rows="5" placeholder="Ask Mover what to do next...">${escapeHtml(starterPrompt)}</textarea>
+          </label>
+        </div>
+        <div class="agent-actions">
+          <button class="btn-copy" id="btn-run-agent">Run locally</button>
+          <button class="btn-copy secondary" id="btn-copy-cmd">Copy fallback</button>
+        </div>
+        <pre class="agent-output mono" id="agent-output">Ready. This runs on 127.0.0.1 through your installed agent CLIs.</pre>
+      </div>
+    `;
+    els.modal.classList.remove("hidden");
+    const copyBtn = $("#btn-copy-cmd");
+    const runBtn = $("#btn-run-agent");
+    const output = $("#agent-output");
+    const promptEl = $("#agent-prompt");
+    const agentEl = $("#agent-select");
+    copyBtn.addEventListener("click", () => {
+      navigator.clipboard.writeText(promptEl.value || workflow).then(() => {
+        copyBtn.textContent = "Copied ✓";
+        copyBtn.style.background = "var(--accent)";
+      });
+    });
+    runBtn.addEventListener("click", () => runAgent({
+      agent: agentEl.value,
+      workflow,
+      prompt: promptEl.value,
+      output,
+      runBtn
+    }));
+  }
+
+  async function runAgent({ agent, workflow, prompt, output, runBtn }) {
+    runBtn.disabled = true;
+    runBtn.textContent = "Running...";
+    output.textContent = "";
+    try {
+      const res = await fetch("/api/agent/run", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ agent, workflow, prompt })
+      });
+      if (!res.ok) throw new Error(await res.text());
+      if (!res.body || !res.body.getReader) {
+        output.textContent = await res.text();
+        return;
+      }
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        output.textContent += decoder.decode(value, { stream: true });
+        output.scrollTop = output.scrollHeight;
+      }
+    } catch (e) {
+      output.textContent += `\n[error] ${e.message || e}\n`;
+    } finally {
+      runBtn.disabled = false;
+      runBtn.textContent = "Run locally";
+    }
+  }
+
+  function closeModal() {
+    if (els.modal) els.modal.classList.add("hidden");
+  }
+
+  function escapeHtml(s) {
+    if (!s) return "";
+    return String(s).replace(/[&<>"']/g, (c) => ({"&":"&amp;","<":"&lt;",">":"&gt;","\"":"&quot;","'":"&#39;"}[c]));
+  }
+
+  function snoozeWorkflow(workflow, durationMs) {
+    const snoozes = JSON.parse(localStorage.getItem("mover-snoozes") || "{}");
+    const until = Date.now() + durationMs;
+    snoozes[workflow] = until;
+    localStorage.setItem("mover-snoozes", JSON.stringify(snoozes));
+    flashCard(workflow, "snoozed 4h");
+  }
+
+  function skipToday(workflow) {
+    const snoozes = JSON.parse(localStorage.getItem("mover-snoozes") || "{}");
+    const tomorrow = new Date();
+    tomorrow.setHours(24, 0, 0, 0);
+    snoozes[workflow] = tomorrow.getTime();
+    localStorage.setItem("mover-snoozes", JSON.stringify(snoozes));
+    flashCard(workflow, "skipped today");
+  }
+
+  function flashCard(workflow, msg) {
+    const card = $$('.suggest-card').find(c => c.dataset.workflow === workflow);
+    if (!card) return;
+    card.style.opacity = "0.4";
+    card.style.pointerEvents = "none";
+    const overlay = document.createElement("div");
+    overlay.style.cssText = "position:absolute;inset:0;display:flex;align-items:center;justify-content:center;background:rgba(20,20,26,0.85);font-family:var(--font-mono);font-size:11px;text-transform:uppercase;letter-spacing:0.1em;color:var(--accent);z-index:10;";
+    overlay.textContent = msg;
+    card.appendChild(overlay);
+    setTimeout(() => {
+      card.style.display = "none";
+    }, 800);
+  }
+
+  function attachSuggestCardHandlers() {
+    $$(".suggest-card").forEach(card => {
+      // Card click → open command modal (default action)
+      card.addEventListener("click", (e) => {
+        if (e.target.closest(".suggest-action-btn")) return;
+        const workflow = card.dataset.workflow;
+        const reason = card.dataset.reason;
+        if (workflow) openCommandModal(workflow, reason);
+      });
+    });
+
+    $$(".suggest-action-btn").forEach(btn => {
+      btn.addEventListener("click", (e) => {
+        e.stopPropagation();
+        const action = btn.dataset.action;
+        const workflow = btn.dataset.workflow;
+        if (action === "run") {
+          openCommandModal(workflow, btn.closest(".suggest-card").dataset.reason);
+        } else if (action === "snooze") {
+          snoozeWorkflow(workflow, 4 * 60 * 60 * 1000);
+        } else if (action === "skip") {
+          skipToday(workflow);
+        }
+      });
+    });
+  }
+
+  function switchMode(mode) {
+    if (!mode) return;
+    $$("[data-mode-panel]").forEach(panel => {
+      panel.classList.toggle("active", panel.dataset.modePanel === mode);
+    });
+    $$("[data-mode-target]").forEach(btn => {
+      btn.classList.toggle("active", btn.dataset.modeTarget === mode);
+    });
+    const main = $("#studio-main");
+    if (main) main.scrollTop = 0;
+  }
+
+  function attachModeHandlers() {
+    $$("[data-mode-target]").forEach(btn => {
+      btn.addEventListener("click", () => switchMode(btn.dataset.modeTarget));
+    });
+  }
+
+  function attachCommandHandlers() {
+    $$("[data-open-workflow]").forEach(btn => {
+      btn.addEventListener("click", () => openCommandModal(btn.dataset.openWorkflow, "Primary action surfaced by today's brief."));
+    });
+    $$("[data-command-trigger]").forEach(btn => {
+      btn.addEventListener("click", () => openCommandModal("Ask Mover", "Ask about the current brief, a receipt, or which workflow to run next."));
+    });
+  }
+
+  function applySnoozes() {
+    const snoozes = JSON.parse(localStorage.getItem("mover-snoozes") || "{}");
+    const now = Date.now();
+    let pruned = false;
+    for (const [workflow, until] of Object.entries(snoozes)) {
+      if (until < now) {
+        delete snoozes[workflow];
+        pruned = true;
+        continue;
+      }
+      const card = $$('.suggest-card').find(c => c.dataset.workflow === workflow);
+      if (card) card.style.display = "none";
+    }
+    if (pruned) localStorage.setItem("mover-snoozes", JSON.stringify(snoozes));
+  }
+
+  function init() {
+    if (els.refresh) els.refresh.addEventListener("click", refresh);
+    if (els.modalClose) els.modalClose.addEventListener("click", closeModal);
+    if (els.modal) {
+      els.modal.addEventListener("click", (e) => {
+        if (e.target === els.modal) closeModal();
+      });
+    }
+
+    attachSuggestCardHandlers();
+    attachModeHandlers();
+    attachCommandHandlers();
+    applySnoozes();
+
+    document.addEventListener("keydown", (e) => {
+      if (e.key === "r" && !e.metaKey && !e.ctrlKey && !["INPUT","TEXTAREA"].includes(document.activeElement.tagName)) {
+        refresh();
+      } else if (e.key === "Escape") {
+        closeModal();
+      }
+    });
+
+    setInterval(tickClock, 60000);
+    setInterval(refresh, REFRESH_INTERVAL);
+  }
+
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", init);
+  } else {
+    init();
+  }
+})();

package/src/dashboard/index.js

@@ -0,0 +1,319 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { spawn } = require("child_process");
+const { build } = require("./build");
+const { startServer } = require("./server");
+
+// Phase 41.3 — Daemon mode. `moveros pulse --daemon` detaches the dashboard
+// server from the terminal so closing the terminal doesn't kill it.
+// State files at ~/.mover/dashboard/:
+//   .pid    — pid of the detached server process
+//   .stdout — server stdout (rotated when >1MB)
+//   .stderr — server stderr (rotated when >1MB)
+//
+// Also: --status to print whether daemon is alive, --stop to kill it.
+const DAEMON_DIR = path.join(os.homedir(), ".mover", "dashboard");
+const PID_FILE = path.join(DAEMON_DIR, ".pid");
+const STDOUT_LOG = path.join(DAEMON_DIR, ".stdout");
+const STDERR_LOG = path.join(DAEMON_DIR, ".stderr");
+const TOKEN_FILE = path.join(DAEMON_DIR, ".token");
+
+function isAlive(pid) {
+  if (!pid) return false;
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+function readPidFile() {
+  try {
+    const raw = fs.readFileSync(PID_FILE, "utf8").trim();
+    const pid = parseInt(raw, 10);
+    return Number.isFinite(pid) && pid > 0 ? pid : null;
+  } catch { return null; }
+}
+
+async function run(opts = {}) {
+  const vault = opts.vault || resolveVault();
+  if (!vault) {
+    console.error("✗ Could not resolve vault path. Run `moveros doctor` to diagnose.");
+    process.exit(1);
+  }
+
+  const version = opts.version || readPackageVersion();
+  const rest = opts.rest || [];
+
+  if (rest.includes("--status")) {
+    return statusCommand();
+  }
+  if (rest.includes("--stop")) {
+    return stopCommand();
+  }
+  if (rest.includes("--daemon")) {
+    return daemonCommand({ vault, version });
+  }
+
+  if (rest.includes("--static")) {
+    // Static mode: just regenerate HTML, no server
+    const result = await build({ vault, version });
+    console.log(`✓ Dashboard built at ${result.builtAt.toISOString()} (${result.durationMs}ms, ${result.sectionCount} sections)`);
+    if (result.errors.length > 0) {
+      console.log(`  ${result.errors.length} non-fatal errors logged to ~/.mover/dashboard/build.log`);
+    }
+    return;
+  }
+
+  await startServer({
+    buildFn: () => build({ vault, version }),
+    vault,
+    version,
+    openBrowser: !rest.includes("--no-open")
+  });
+}
+
+// ─── moveros open ───────────────────────────────────────────────────────────
+// Ensure the dashboard server is up (start it detached if not), then open it
+// in the browser and EXIT. This is what the desktop launcher (shortcut.js →
+// `node install.js open`) invokes, and what the install flow can call to land
+// the user in the dashboard. Unlike `pulse` (which holds the terminal in the
+// foreground), `open` returns immediately so a Finder/Explorer double-click
+// doesn't leave a process attached to nothing.
+async function openCommand({ vault, version, soft = false, noOpen = false, route = "" } = {}) {
+  vault = vault || resolveVault();
+  if (!vault) {
+    console.error("✗ Could not resolve vault path. Run `moveros doctor` to diagnose.");
+    process.exitCode = 1;
+    return;
+  }
+
+  const pid = readPidFile();
+  const alive = pid && isAlive(pid);
+
+  // Soft open (bare `moveros`): if the server is already up, the tab is almost
+  // certainly already open — don't spawn another one on a reflexive re-run.
+  // Just point at it. `moveros open` (soft=false) always (re)opens the tab.
+  if (alive && soft && !noOpen) {
+    const running = readTokenUrl() || "http://127.0.0.1:3737";
+    console.log(`✓ Mover Studio is already running: ${running}`);
+    console.log(`  Reopen the tab with: moveros open`);
+    return;
+  }
+
+  if (alive) {
+    console.log(`✓ Dashboard already running (PID ${pid}).`);
+  } else {
+    // Start the detached background server (reuses the daemon spawn). It binds
+    // the port and writes ~/.mover/dashboard/.token with the real URL once the
+    // server is listening — which is what we poll for below.
+    daemonCommand({ vault, version });
+  }
+
+  const base = await waitForServer({ timeoutMs: 20000 });
+  if (!base) {
+    console.error("✗ Dashboard did not become reachable in time.");
+    console.error(`  Logs: ${STDOUT_LOG}`);
+    console.error("  Foreground fallback: moveros pulse");
+    console.error("  Diagnose: moveros doctor");
+    process.exitCode = 1;
+    return;
+  }
+  const url = route ? base.replace(/\/+$/, "") + route : base;
+
+  // A missing browser is NOT a failure when the server is reachable — print the
+  // URL and exit 0 (headless / SSH). openUrl already swallows spawn errors.
+  if (noOpen) {
+    console.log(`  Mover Studio ready: ${url}`);
+    return;
+  }
+  openUrl(url);
+  console.log(`  Opening Mover Studio: ${url}`);
+}
+
+// Read the real URL the server is serving on (port may fall back from 3737).
+function readTokenUrl() {
+  try {
+    const t = JSON.parse(fs.readFileSync(TOKEN_FILE, "utf8"));
+    return t && t.url ? t.url : null;
+  } catch { return null; }
+}
+
+// One HTTP probe. Resolves true if the server answers at all (any status —
+// even 404 means it's bound and serving), false on connect error/timeout.
+function pingUrl(url, timeoutMs) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (v) => { if (!settled) { settled = true; resolve(v); } };
+    try {
+      const http = require("http");
+      const req = http.get(url, (res) => { res.resume(); done(true); });
+      req.setTimeout(timeoutMs, () => { req.destroy(); done(false); });
+      req.on("error", () => done(false));
+    } catch { done(false); }
+  });
+}
+
+// Poll the token URL until the server actually answers. Handles both "just
+// started, not bound yet" and "stale token pointing at a dead port" — in both
+// cases pingUrl fails and we keep waiting until a live server responds or we
+// time out. Date.now() is fine here (normal Node CLI, not a workflow sandbox).
+async function waitForServer({ timeoutMs = 20000 } = {}) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const url = readTokenUrl();
+    if (url && await pingUrl(url, 1500)) return url;
+    await new Promise((r) => setTimeout(r, 250));
+  }
+  return null;
+}
+
+// Cross-platform browser open, fire-and-forget (detached so it never holds
+// our process open). Mirrors server.js::tryOpenBrowser.
+function openUrl(url) {
+  const platform = process.platform;
+  let cmd, args;
+  if (platform === "darwin") { cmd = "open"; args = [url]; }
+  else if (platform === "win32") { cmd = "cmd"; args = ["/c", "start", "", url]; }
+  else { cmd = "xdg-open"; args = [url]; }
+  try { spawn(cmd, args, { stdio: "ignore", detached: true }).unref(); }
+  catch { /* URL was printed above — user can open it manually */ }
+}
+
+function statusCommand() {
+  const pid = readPidFile();
+  if (pid && isAlive(pid)) {
+    let url = "http://127.0.0.1:3737";
+    try {
+      const tokenFile = path.join(DAEMON_DIR, ".token");
+      if (fs.existsSync(tokenFile)) {
+        const t = JSON.parse(fs.readFileSync(tokenFile, "utf8"));
+        url = t.url || url;
+      }
+    } catch {}
+    console.log(`✓ Mover dashboard daemon running`);
+    console.log(`  PID: ${pid}`);
+    console.log(`  URL: ${url}`);
+    console.log(`  Logs: ${STDOUT_LOG} / ${STDERR_LOG}`);
+    return;
+  }
+  if (pid) {
+    console.log(`✗ Stale pid file (${pid}) — process not running.`);
+    try { fs.unlinkSync(PID_FILE); } catch {}
+    return;
+  }
+  console.log(`✗ Mover dashboard daemon not running.`);
+  console.log(`  Start with: moveros pulse --daemon`);
+}
+
+function stopCommand() {
+  const pid = readPidFile();
+  if (!pid || !isAlive(pid)) {
+    console.log(`No daemon running.`);
+    try { fs.unlinkSync(PID_FILE); } catch {}
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    console.log(`✓ Sent SIGTERM to daemon (PID ${pid}).`);
+    try { fs.unlinkSync(PID_FILE); } catch {}
+  } catch (e) {
+    console.error(`✗ Could not stop daemon: ${e.message}`);
+  }
+}
+
+function daemonCommand({ vault, version }) {
+  // Refuse to start a second daemon
+  const existing = readPidFile();
+  if (existing && isAlive(existing)) {
+    console.log(`✓ Daemon already running (PID ${existing}).`);
+    console.log(`  URL: http://127.0.0.1:3737`);
+    console.log(`  Stop with: moveros pulse --stop`);
+    return;
+  }
+  try { fs.mkdirSync(DAEMON_DIR, { recursive: true }); } catch {}
+
+  // Start-lock: stop two near-simultaneous `moveros` runs (server down) from
+  // each spawning a server and racing for the port. Atomic O_EXCL create; a
+  // stale lock (crash mid-start) is reclaimed after 15s. A lock *failure* must
+  // never block startup — only a genuine EEXIST race reuses the in-flight start.
+  const START_LOCK = path.join(DAEMON_DIR, "start.lock");
+  let haveLock = false;
+  try {
+    const lst = fs.statSync(START_LOCK);
+    if (Date.now() - lst.mtimeMs < 15000) {
+      console.log("✓ Dashboard is already starting — reusing it.");
+      return;
+    }
+    fs.unlinkSync(START_LOCK); // stale
+  } catch {}
+  try {
+    fs.closeSync(fs.openSync(START_LOCK, "wx"));
+    haveLock = true;
+  } catch (e) {
+    if (e && e.code === "EEXIST") {
+      console.log("✓ Dashboard is already starting — reusing it.");
+      return;
+    }
+    // Any other lock error → don't block startup; proceed without the lock.
+  }
+
+  // Rotate logs if too large
+  for (const log of [STDOUT_LOG, STDERR_LOG]) {
+    try {
+      const st = fs.statSync(log);
+      if (st.size > 1024 * 1024) fs.renameSync(log, log + ".old");
+    } catch {}
+  }
+
+  const stdout = fs.openSync(STDOUT_LOG, "a");
+  const stderr = fs.openSync(STDERR_LOG, "a");
+
+  // Spawn ourselves with --no-open to skip the browser launch, no --daemon
+  // (so the child runs the actual server). Detached + unref so the child
+  // outlives this process.
+  const nodeBin = process.execPath;
+  const entry = path.join(__dirname, "..", "..", "install.js");
+  const args = ["pulse", "--no-open"];
+  const child = spawn(nodeBin, [entry, ...args], {
+    detached: true,
+    stdio: ["ignore", stdout, stderr],
+    env: { ...process.env, MOVER_DAEMON: "1" },
+    cwd: vault,
+  });
+  child.unref();
+
+  fs.writeFileSync(PID_FILE, String(child.pid), "utf8");
+  if (haveLock) { try { fs.unlinkSync(START_LOCK); } catch {} }
+  console.log(`✓ Mover dashboard daemon started`);
+  console.log(`  PID: ${child.pid}`);
+  console.log(`  URL: http://127.0.0.1:3737`);
+  console.log(`  Logs: ${STDOUT_LOG}`);
+  console.log(`  Stop: moveros pulse --stop`);
+  console.log(`  Status: moveros pulse --status`);
+  // Touch unused params so linters don't flag (version inherited by child).
+  void vault; void version;
+}
+
+function resolveVault() {
+  // Use install.js's resolveVaultPath if available
+  try {
+    const installPath = require("path").join(__dirname, "..", "..", "install.js");
+    // We can't require install.js directly because it has side effects on require.
+    // Instead, replicate the simple config-based resolution.
+    const { moverConfigPath, safeReadJson } = require("./lib/paths");
+    const config = safeReadJson(moverConfigPath());
+    if (config && config.vaultPath) return config.vaultPath;
+  } catch {}
+  return null;
+}
+
+function readPackageVersion() {
+  try {
+    const pkg = require("../../package.json");
+    return pkg.version || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+module.exports = { run, build, open: openCommand };