@lyric_dev/data-loom 0.6.0 → 0.8.0

package/dist/mcpShim.js

@@ -0,0 +1,144 @@
+// MCP stdio shim: spawned by a client (typically Claude Code's stdio
+// registration), it ensures the daemon is running, then proxies MCP traffic
+// between its own stdio and the daemon's loopback HTTP `/mcp` endpoint for the
+// life of the client session.
+//
+// Pure proxy — no tools, prompts, or sessions of its own. The daemon remains
+// the single MCP server and source of truth (including per-call project
+// resolution); this file only launches (if needed) and forwards raw JSON-RPC
+// messages both ways.
+import { readFile } from "node:fs/promises";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { isInitializeRequest, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+import * as lifecycle from "./lifecycle.js";
+import { mcpUrl, logFile } from "./paths.js";
+const LAUNCH_TIMEOUT_MS = 10_000;
+const POLL_INTERVAL_MS = 300;
+const delay = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * Ensure the daemon answers on the loopback port, starting it (through the
+ * normal detached lifecycle path) if it does not. Bounded wait — never hangs.
+ * A concurrent second shim racing to start is harmless: the daemon's own
+ * single-instance guard (the port probe in lifecycle.start) means at most one
+ * daemon results, and both shims' polls succeed against it.
+ */
+async function ensureDaemonUp() {
+    if (await lifecycle.isRunning())
+        return { ok: true };
+    await lifecycle.start();
+    const deadline = Date.now() + LAUNCH_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        if (await lifecycle.isRunning())
+            return { ok: true };
+        await delay(POLL_INTERVAL_MS);
+    }
+    return { ok: false, diagnosis: await diagnoseFailure() };
+}
+/** Best-effort explanation of why the daemon never came up, from its own log tail. */
+async function diagnoseFailure() {
+    let tail = "";
+    try {
+        tail = (await readFile(logFile(), "utf8")).slice(-4000);
+    }
+    catch {
+        /* no log yet — daemon likely never got far enough to write one */
+    }
+    if (/openspec.*was not found/i.test(tail)) {
+        return ("DataLoom could not start: the `openspec` CLI is missing. Install it (e.g. `npm i -g openspec`), then retry. " +
+            `Log: ${logFile()}`);
+    }
+    return ("DataLoom's daemon did not come up in time. Run `data-loom status` to check what's wrong, and see the log at " +
+        logFile());
+}
+function extractId(msg) {
+    return "id" in msg ? msg.id : undefined;
+}
+function errorResponse(id, message) {
+    return {
+        jsonrpc: "2.0",
+        id,
+        error: { code: ErrorCode.InternalError, message },
+    };
+}
+/**
+ * stdout is the MCP transport's wire — reserved exclusively for framed
+ * JSON-RPC messages. Reused helpers here (lifecycle.start/isRunning) predate
+ * the shim and log human-readable status with console.log, which writes to
+ * that same stdout; left alone, those lines interleave with JSON-RPC frames
+ * and corrupt the client's stream. Redirect the stdout-writing console
+ * methods to stderr for this process's whole lifetime (console.warn/error
+ * already go to stderr).
+ */
+function keepStdoutForTransportOnly() {
+    console.log = console.error;
+    console.info = console.error;
+    console.debug = console.error;
+}
+/**
+ * Entry point for `data-loom mcp-shim`. Never resolves until the client
+ * session ends (or the launch fails and the handshake has been answered) —
+ * the caller (index.ts) just awaits and lets the process exit naturally.
+ */
+export async function runShim() {
+    keepStdoutForTransportOnly();
+    const stdio = new StdioServerTransport();
+    // Buffer whatever arrives while the daemon is (maybe) still starting, so
+    // nothing sent before the proxy is wired up is lost.
+    const pending = [];
+    stdio.onmessage = (msg) => {
+        pending.push(msg);
+    };
+    stdio.onerror = (err) => console.error("[data-loom mcp-shim] stdio error:", err);
+    await stdio.start();
+    const readiness = await ensureDaemonUp();
+    if (!readiness.ok) {
+        const initMsg = pending.find((m) => isInitializeRequest(m));
+        const id = initMsg ? extractId(initMsg) : undefined;
+        if (id !== undefined) {
+            await stdio.send(errorResponse(id, readiness.diagnosis));
+        }
+        else {
+            // No handshake to answer yet — still surface the failure, just not as
+            // an MCP response. Never exit without saying why.
+            console.error(`[data-loom mcp-shim] ${readiness.diagnosis}`);
+        }
+        await stdio.close();
+        process.exitCode = 1;
+        return;
+    }
+    const client = new StreamableHTTPClientTransport(new URL(mcpUrl()));
+    let closing = false;
+    // The shim's whole job ends with its client session — one side closing
+    // (client disconnects, or the daemon connection drops) tears down the
+    // other, but the daemon itself is never touched.
+    const closeBoth = () => {
+        if (closing)
+            return;
+        closing = true;
+        void stdio.close();
+        void client.close();
+        process.exit(0);
+    };
+    client.onmessage = (msg) => {
+        void stdio.send(msg);
+    };
+    client.onerror = (err) => console.error("[data-loom mcp-shim] daemon connection error:", err);
+    client.onclose = closeBoth;
+    stdio.onerror = (err) => console.error("[data-loom mcp-shim] stdio error:", err);
+    stdio.onclose = closeBoth;
+    // StdioServerTransport only ever calls onclose when *we* call close() — it
+    // does not itself listen for stdin ending. The client process closing its
+    // end of the pipe (the real "session ended" signal) only shows up as
+    // stdin's own 'end'/'close' event, so that is what actually has to trigger
+    // teardown here.
+    process.stdin.on("end", closeBoth);
+    process.stdin.on("close", closeBoth);
+    await client.start();
+    for (const msg of pending)
+        await client.send(msg);
+    // From here on, every message from the client goes straight through.
+    stdio.onmessage = (msg) => {
+        void client.send(msg);
+    };
+}

package/dist/paths.js

@@ -31,6 +31,12 @@ export function stateDir() {
 }
 export const pidFile = () => join(stateDir(), "daemon.pid");
 export const logFile = () => join(stateDir(), "daemon.log");
+/**
+ * The stable launcher OS supervisors invoke (Scheduled Task / LaunchAgent /
+ * systemd unit) — a fixed path that never changes across Node version or
+ * package-location churn, unlike the `node` + script paths it wraps.
+ */
+export const launcherFile = () => join(stateDir(), process.platform === "win32" ? "daemon.cmd" : "daemon.sh");
 /** Create the state dir on demand; safe to call repeatedly. */
 export async function ensureStateDir() {
     const dir = stateDir();

package/dist/server.js

@@ -15,7 +15,7 @@ const MIME = {
     ".svg": "image/svg+xml",
 };
 export async function startServer(opts) {
-    const { publicDir, host, port, getRoadmap, getMcp, checkMcp, getProjects, selectProject, getCurrentProject } = opts;
+    const { publicDir, host, port, getRoadmap, getMcp, checkMcp, getProjects, selectProject, getCurrentProject, onShutdown } = opts;
     let wss;
     const broadcast = (msg) => {
         const data = JSON.stringify(msg);
@@ -147,6 +147,15 @@ export async function startServer(opts) {
                 return sendJson(res, getMcp());
             if (url.pathname === "/api/projects")
                 return sendJson(res, await getProjects());
+            if (url.pathname === "/api/shutdown" && req.method === "POST") {
+                // Loopback-only (isAllowed already ran) graceful stop. Answer first,
+                // then trigger shutdown once the response has flushed so the caller
+                // gets its 200 before the process exits.
+                res.writeHead(200, { "content-type": MIME[".json"] });
+                res.end(JSON.stringify({ stopping: true }));
+                res.on("finish", () => setImmediate(() => onShutdown?.()));
+                return;
+            }
             if (url.pathname === "/api/mcp/check" && req.method === "POST") {
                 const server = await checkMcp(url.searchParams.get("name") ?? "");
                 if (!server)

package/dist/version.js

@@ -0,0 +1,18 @@
+// The advertised package version — read from the manifest shipped next to the
+// compiled code, so it can never drift from the released version again (it was
+// hardcoded in mcpServer.ts and stuck at 0.4.1 through the 0.5.0 release).
+// Shared by the MCP server (server version), the weave alias (version stamp),
+// and the startup refresh (comparing stamps).
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+export const VERSION = (() => {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        const manifest = JSON.parse(readFileSync(join(here, "..", "package.json"), "utf8"));
+        return manifest.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+})();

package/dist/weaveAlias.js

@@ -0,0 +1,66 @@
+// Shared provisioning for the `/loom:weave` alias: a thin, version-stamped
+// command file that delegates to the data-loom MCP server's `weave` prompt
+// (see mcpServer.ts) instead of carrying the workflow text itself. Written by
+// the install_weave_skill tool, `connect claude-code`, and healed on daemon
+// startup — all three must agree on path, stamp format, and template, so it
+// lives here rather than duplicated across callers.
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+export const WEAVE_ALIAS_PATH = join(homedir(), ".claude", "commands", "loom", "weave.md");
+const STAMP_RE = /<!--\s*data-loom:version\s+(\S+?)\s*-->/;
+function buildAlias(version) {
+    return `---
+name: "Loom: Weave"
+description: "Review the open proposals and weave their dependency order via the data-loom MCP server"
+category: Workflow
+tags: [loom, dependencies, mcp, review]
+---
+
+<!-- data-loom:version ${version} -->
+
+Fetch the **data-loom** MCP server's \`weave\` prompt (\`prompts/get\` with name \`weave\`) and follow it exactly — that prompt is this workflow's single source of truth and always matches the running server.
+
+**If the data-loom tools or the \`weave\` prompt are unreachable:** the daemon is almost certainly not running or not registered in this session. Tell the user to check \`data-loom status\`, start it with \`data-loom start\` if it isn't running, and register it with \`data-loom connect claude-code\` if it isn't registered — then retry.
+`;
+}
+async function readAlias() {
+    try {
+        return await readFile(WEAVE_ALIAS_PATH, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+/** Write the current alias, creating its parent directory if absent. Returns the path written. */
+export async function provisionWeaveAlias(version) {
+    await mkdir(dirname(WEAVE_ALIAS_PATH), { recursive: true });
+    await writeFile(WEAVE_ALIAS_PATH, buildAlias(version));
+    return WEAVE_ALIAS_PATH;
+}
+/**
+ * On daemon startup: rewrite an existing alias whose version stamp is missing
+ * or does not match the running version (covers both a prior version's alias
+ * and a pre-prompt full-text install, which predates the stamp). Never creates
+ * the file — absence means the user hasn't opted in via connect or the tool.
+ */
+export async function refreshWeaveAliasIfOutdated(version) {
+    const text = await readAlias();
+    if (text === null)
+        return;
+    if (text.match(STAMP_RE)?.[1] === version)
+        return;
+    await provisionWeaveAlias(version);
+}
+/**
+ * Remove the alias only when it carries a data-loom version stamp — our
+ * positive signal of ownership. A file with no stamp at all (or no file) is
+ * left untouched. Returns whether a file was removed.
+ */
+export async function removeWeaveAliasIfOurs() {
+    const text = await readAlias();
+    if (text === null || !STAMP_RE.test(text))
+        return false;
+    await unlink(WEAVE_ALIAS_PATH);
+    return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lyric_dev/data-loom",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Local dashboard for spec-driven development: a phased OpenSpec roadmap (WHAT) and an MCP topology (HOW).",
   "type": "module",
   "license": "MIT",

package/public/app.js

@@ -180,8 +180,12 @@ function renderReview() {
   reviewEl.appendChild(el("span", "review-badge", String(n)));
   const txt = el("span", "review-text");
   const subject = n > 1 ? "proposals need" : "proposal needs";
-  txt.innerHTML = `${n} ${subject} dependency review — ask Claude to <b>weave</b> ${n > 1 ? "them" : "it"} via the data-loom MCP server.`;
+  txt.innerHTML = `${n} ${subject} dependency review — copy the <b>weave</b> command to run it in Claude Code.`;
   reviewEl.appendChild(txt);
+  const btn = el("button", "banner-action", "Weave");
+  btn.title = "Copy /loom:weave";
+  btn.addEventListener("click", () => copyCommand("/loom:weave"));
+  reviewEl.appendChild(btn);
 }
 
 function clearBoard() {
@@ -272,6 +276,16 @@ function renderCard(c) {
     const text = [capsParts.join("  "), tasks].filter(Boolean).join(" · ");
     body.appendChild(el("div", "gcard-caps", text));
   }
+  const action = changeAction(c);
+  if (action) {
+    const btn = el("button", "card-action " + action.kind, action.label);
+    btn.title = "Copy " + action.command;
+    btn.addEventListener("click", (ev) => {
+      ev.stopPropagation(); // copy only — don't also select the card / open detail
+      copyCommand(action.command);
+    });
+    body.appendChild(btn);
+  }
   card.appendChild(body);
 
   if (nextUpNames.has(c.name)) card.appendChild(el("div", "gcard-next", "NEXT UP"));
@@ -524,6 +538,13 @@ function renderChangeDetail(c) {
   pills.appendChild(rp);
   inner.appendChild(pills);
 
+  const action = changeAction(c);
+  if (action) {
+    const btn = el("button", "detail-action " + action.kind, "Copy " + action.command);
+    btn.addEventListener("click", () => copyCommand(action.command));
+    inner.appendChild(btn);
+  }
+
   if (c.totalTasks > 0) {
     const pct = Math.round((c.completedTasks / c.totalTasks) * 100);
     const tasks = el("div", "detail-tasks");
@@ -607,6 +628,57 @@ function itemList(items, cls, prefix) {
   return list;
 }
 
+// ═══════════════ command handoff (clipboard + toast) ═══════════════
+
+// A single reused toast node, auto-dismissed. DataLoom prepares a command; the
+// user runs it in their own Claude Code session — so a copy is confirmed here,
+// never executed.
+let toastEl = null;
+let toastTimer = null;
+function showToast(message, tone) {
+  if (!toastEl) {
+    toastEl = el("div", "toast");
+    document.body.appendChild(toastEl);
+  }
+  toastEl.textContent = message;
+  toastEl.className = "toast" + (tone ? " " + tone : "");
+  // force reflow so re-triggering the transition restarts it
+  void toastEl.offsetWidth;
+  toastEl.classList.add("show");
+  clearTimeout(toastTimer);
+  toastTimer = setTimeout(() => toastEl.classList.remove("show"), 3200);
+}
+
+// Copy a Claude Code command to the clipboard and confirm via a toast. Purely
+// client-side: no network call, no daemon/agent activity. On localhost the
+// Clipboard API is available (secure context); a rejection or its absence falls
+// back to showing the command for manual copy.
+async function copyCommand(command) {
+  try {
+    await navigator.clipboard.writeText(command);
+    showToast(`Copied ${command} — paste into Claude Code`);
+  } catch {
+    showToast(`Couldn't copy — run this in Claude Code: ${command}`, "warn");
+  }
+}
+
+// The command action a change offers, derived from state the model already
+// carries. Kept in one place so a card and the detail panel always agree:
+//   archived            → nothing
+//   tasks all complete  → archive
+//   ready (incomplete)  → apply
+//   otherwise           → nothing
+function changeAction(c) {
+  if (c.archived) return null;
+  if (c.totalTasks > 0 && c.completedTasks === c.totalTasks) {
+    return { kind: "archive", label: "Archive", command: "/opsx:archive " + c.name };
+  }
+  if (c.readiness === "ready") {
+    return { kind: "apply", label: "Apply", command: "/opsx:apply " + c.name };
+  }
+  return null;
+}
+
 // ═══════════════ helpers ═══════════════
 
 function statusColor(status) {

package/public/style.css

@@ -540,6 +540,108 @@ main {
   color: var(--text);
   font-family: var(--prose);
 }
+.banner-action {
+  flex: none;
+  margin-left: auto;
+  font-family: var(--prose);
+  font-weight: 600;
+  font-size: 12px;
+  padding: 6px 15px;
+  border-radius: 8px;
+  border: 1px solid var(--accent-bd);
+  background: var(--panel);
+  color: var(--accent);
+  cursor: pointer;
+  transition: background 0.15s, color 0.15s;
+}
+.banner-action:hover {
+  background: var(--accent);
+  color: var(--on-accent);
+}
+
+/* ===== Command handoff: card/detail actions + toast ===== */
+.card-action {
+  align-self: flex-start;
+  margin-top: 10px;
+  font-family: var(--prose);
+  font-weight: 600;
+  font-size: 11px;
+  padding: 4px 11px;
+  border-radius: 7px;
+  border: 1px solid var(--accent-bd);
+  background: var(--accent-soft);
+  color: var(--accent);
+  cursor: pointer;
+  transition: background 0.15s, color 0.15s;
+}
+.card-action:hover {
+  background: var(--accent);
+  color: var(--on-accent);
+}
+.card-action.archive {
+  border-color: var(--c-done);
+  color: var(--c-done);
+  background: transparent;
+}
+.card-action.archive:hover {
+  background: var(--c-done);
+  color: var(--on-accent);
+}
+
+.detail-action {
+  margin-top: 16px;
+  width: 100%;
+  font-family: var(--prose);
+  font-weight: 600;
+  font-size: 12.5px;
+  padding: 9px;
+  border-radius: 9px;
+  border: 1px solid var(--accent-bd);
+  background: var(--accent-soft);
+  color: var(--accent);
+  cursor: pointer;
+  transition: background 0.15s, color 0.15s;
+}
+.detail-action:hover {
+  background: var(--accent);
+  color: var(--on-accent);
+}
+.detail-action.archive {
+  border-color: var(--c-done);
+  color: var(--c-done);
+}
+.detail-action.archive:hover {
+  background: var(--c-done);
+  color: var(--on-accent);
+}
+
+.toast {
+  position: fixed;
+  left: 50%;
+  bottom: 26px;
+  transform: translate(-50%, 12px);
+  max-width: min(70vw, 480px);
+  padding: 11px 16px;
+  border-radius: 10px;
+  background: var(--panel);
+  border: 1px solid var(--accent-bd);
+  color: var(--text);
+  font-family: var(--mono);
+  font-size: 12px;
+  box-shadow: var(--shadow);
+  opacity: 0;
+  pointer-events: none;
+  z-index: 40;
+  transition: opacity 0.18s ease, transform 0.18s ease;
+}
+.toast.show {
+  opacity: 1;
+  transform: translate(-50%, 0);
+}
+.toast.warn {
+  border-color: var(--c-warn);
+  color: var(--c-warn);
+}
 
 /* ===== MCP Topology: circuit board ===== */
 .topo-controls {