@systemdox/mcp-server 0.1.57 → 0.1.58

package/dist/http.js

@@ -873,8 +873,8 @@ function registerGetPlanBoard(server, apiClient) {
             ]
           };
         }
-        const open = boards.filter((b) => !b.closed);
-        if (open.length === 0) {
+        const open2 = boards.filter((b) => !b.closed);
+        if (open2.length === 0) {
           return {
             content: [
               {
@@ -884,16 +884,16 @@ function registerGetPlanBoard(server, apiClient) {
             ]
           };
         }
-        const closedNote = boards.length > open.length ? `
+        const closedNote = boards.length > open2.length ? `
 
-_${boards.length - open.length} closed board(s) not listed._` : "";
+_${boards.length - open2.length} closed board(s) not listed._` : "";
         return {
           content: [
             {
               type: "text",
-              text: `${open.length} open project board(s):
+              text: `${open2.length} open project board(s):
 
-${formatBoards(open)}` + closedNote + `
+${formatBoards(open2)}` + closedNote + `
 
 Call get_plan_board with project_number to list a board's issues.`
             }
@@ -3040,7 +3040,7 @@ var PERSON_ID_RE = new RegExp(`^${PERSON_ID}$`);
 
 // src/sync-memory.ts
 import { existsSync as existsSync3 } from "fs";
-import { mkdir as mkdir3, readdir as readdir2, readFile as readFile4, rm as rm3, writeFile as writeFile3 } from "fs/promises";
+import { appendFile, mkdir as mkdir3, open, readdir as readdir2, readFile as readFile4, rename as rename2, rm as rm3, stat, writeFile as writeFile3 } from "fs/promises";
 import { dirname as dirname3, join as join4, resolve as resolve3 } from "path";
 
 // src/lib/memory-sync.ts
@@ -3064,15 +3064,41 @@ function readFrontmatter(text3) {
   const m = BLOCK_RE.exec(text3);
   if (!m) return void 0;
   const front = { shareFalse: false };
-  for (const line of m[1].split(/\r?\n/)) {
-    const kv = /^([A-Za-z_][\w-]*)[ \t]*:[ \t]*(.*?)[ \t]*$/.exec(line);
+  const lines = m[1].split(/\r?\n/);
+  if (lines.some((l) => /^[ \t]*\t/.test(l) && l.trim())) return front;
+  let topType;
+  let topShare;
+  let nestedType;
+  let nestedShare;
+  let inMetadata = false;
+  let nestedIndent;
+  for (const line of lines) {
+    if (!line.trim() || /^[ \t]*#/.test(line)) continue;
+    const indent = /^ */.exec(line)[0].length;
+    if (indent === 0) {
+      inMetadata = /^metadata[ \t]*:[ \t]*(#.*)?$/.test(line);
+      nestedIndent = void 0;
+    }
+    const kv = /^ *([A-Za-z_][\w-]*)[ \t]*:[ \t]*(.*?)[ \t]*$/.exec(line);
     if (!kv) continue;
     const raw = kv[2].replace(/[ \t]+#.*$/, "");
     const quoted = /^(["'])(.*)\1$/.exec(raw);
     const value = quoted ? quoted[2] : raw;
-    if (kv[1] === "type") front.type = value.trim().toLowerCase();
-    if (kv[1] === "share") front.shareFalse = quoted ? value.trim().toLowerCase() === "false" : YAML_FALSE.has(value);
-  }
+    const isFalse = quoted ? value.trim().toLowerCase() === "false" : YAML_FALSE.has(value);
+    if (indent === 0) {
+      if (kv[1] === "type") topType = value.trim().toLowerCase();
+      if (kv[1] === "share") topShare = isFalse;
+      continue;
+    }
+    if (!inMetadata) continue;
+    nestedIndent ??= indent;
+    if (indent !== nestedIndent) continue;
+    if (kv[1] === "type") nestedType = value.trim().toLowerCase();
+    if (kv[1] === "share") nestedShare = isFalse;
+  }
+  const type = topType ?? nestedType;
+  if (type !== void 0) front.type = type;
+  front.shareFalse = (topShare ?? nestedShare) === true;
   return front;
 }
 function isShareable(path, text3) {
@@ -3313,18 +3339,50 @@ function lineDiff(before, after) {
 }
 
 // src/sync-memory.ts
+var HOOK_LOG_MAX_BYTES = 1024 * 1024;
 var SYNC_MEMORY_COMMAND = "npx -y @systemdox/mcp-server sync-memory";
 var SyncFailed = class extends Error {
 };
+var SyncStopped = class extends Error {
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+  }
+  reason;
+};
+function failureReason(e) {
+  if (e instanceof SyncStopped) return e.reason;
+  const { status, code } = refusal(e);
+  if (status !== void 0) return code ? `SystemDox refused it, ${code}` : "SystemDox refused it";
+  const err = e;
+  const net = err?.cause?.code ?? err?.code ?? "";
+  if (e instanceof TypeError || /^(ECONN|ENOTFOUND|EAI_AGAIN|ETIMEDOUT|EHOSTUNREACH|ENETUNREACH|UND_ERR)/.test(net)) {
+    return "SystemDox could not be reached";
+  }
+  return "it could not finish";
+}
+async function writeWhole(path, text3) {
+  await mkdir3(dirname3(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  try {
+    await writeFile3(tmp, text3, "utf8");
+    await rename2(tmp, path);
+  } catch (e) {
+    await rm3(tmp, { force: true });
+    throw e;
+  }
+}
 function refusal(e) {
   if (!(e instanceof Error)) return {};
   const { status, code } = e;
   return { status: typeof status === "number" ? status : void 0, code: typeof code === "string" ? code : void 0 };
 }
 var toPath = (root, rel) => join4(root, ...rel.split("/"));
+var LEFT_TEMP_RE = /\.\d+\.[a-z0-9]+\.tmp$/;
 async function readFolder(root) {
   const files = {};
   const names = /* @__PURE__ */ new Set();
+  const temps = [];
   async function walk2(dir, prefix) {
     for (const e of await readdir2(dir, { withFileTypes: true })) {
       if (e.name.startsWith(".")) continue;
@@ -3332,12 +3390,13 @@ async function readFolder(root) {
       if (e.isDirectory()) await walk2(join4(dir, e.name), rel);
       else if (e.isFile()) {
         names.add(rel.toLowerCase());
+        if (LEFT_TEMP_RE.test(e.name)) temps.push(rel);
         if (e.name.endsWith(".md")) files[rel] = await readFile4(join4(dir, e.name), "utf8");
       }
     }
   }
   if (existsSync3(root)) await walk2(root, "");
-  return { files, names };
+  return { files, names, temps };
 }
 async function pullTeam(client, ws, project) {
   try {
@@ -3386,7 +3445,11 @@ var Report = class {
   deletedHere = /* @__PURE__ */ new Set();
   deletedFromTeam = /* @__PURE__ */ new Set();
   conflicts = [];
+  /** The conflict copies written this run, by name. */
+  copies = /* @__PURE__ */ new Set();
   skipped = /* @__PURE__ */ new Map();
+  /** Skipped files a sync in the member's terminal can send: held for a value, or for the vault. */
+  waiting = /* @__PURE__ */ new Set();
   people = [];
   toAnswer = /* @__PURE__ */ new Map();
   add(plan) {
@@ -3394,12 +3457,32 @@ var Report = class {
     plan.pushed.forEach((p) => this.pushed.add(p));
     plan.deletedHere.forEach((p) => this.deletedHere.add(p));
     plan.deletedFromTeam.forEach((p) => this.deletedFromTeam.add(p));
-    for (const c of plan.conflicts) this.conflicts.push(`${c.path}: the team's text; yours is beside it as ${c.copy}`);
+    for (const c of plan.conflicts) {
+      this.conflicts.push(`${c.path}: the team's text; yours is beside it as ${c.copy}`);
+      this.copies.add(c.copy);
+    }
     for (const line of plan.indexTeamLines) this.conflicts.push(`${INDEX_FILE}: your line was kept; the team's was: ${line}`);
   }
   skip(path, reason) {
     if (!this.skipped.has(path)) this.skipped.set(path, reason);
   }
+  /** Skipped, and waiting for the member at a terminal. */
+  wait(path, reason) {
+    this.skip(path, reason);
+    this.waiting.add(path);
+  }
+  summary(outcome, version, reason) {
+    return {
+      outcome,
+      ...reason ? { reason } : {},
+      version,
+      pulled: this.pulled.size,
+      pushed: this.pushed.size,
+      deleted: this.deletedHere.size + this.deletedFromTeam.size,
+      conflictCopies: [...this.copies].sort(),
+      waiting: [...this.waiting].sort()
+    };
+  }
   lines(summary, dryRun) {
     const out = [summary];
     const section = (title, items) => {
@@ -3502,7 +3585,7 @@ async function people(opts, ws, files, report, hint) {
           for (const path of g.files) {
             if (leftOut.has(path)) continue;
             current[path] = addShareFalse(current[path]);
-            await writeFile3(toPath(opts.dir, path), current[path], "utf8");
+            await writeWhole(toPath(opts.dir, path), current[path]);
             leftOut.add(path);
           }
           report.people.push({ kind: g.kind, answer: "left out (share: false)", files: g.files.length });
@@ -3605,7 +3688,7 @@ async function people(opts, ws, files, report, hint) {
     const yes = /^y(es)?$/i.test((await ask(`Rewrite ${paths.length} file${paths.length === 1 ? "" : "s"} as shown? [y/N] `)).trim());
     if (yes) {
       for (const path of paths) {
-        await writeFile3(toPath(opts.dir, path), rewritten[path], "utf8");
+        await writeWhole(toPath(opts.dir, path), rewritten[path]);
         current[path] = rewritten[path];
       }
     }
@@ -3620,11 +3703,11 @@ async function people(opts, ws, files, report, hint) {
     held.add(path);
     const keys = pending.filter((f) => f.kind !== HOME_PATH).map((f) => groupKey(f.kind, f.normalised));
     if (keys.some((k) => vaultDown.has(k))) {
-      report.skip(path, "the vault did not answer (SYD-K019) for a value in it; it syncs once the value is filed");
+      report.wait(path, "the vault did not answer (SYD-K019) for a value in it; it syncs once the value is filed");
     } else if (keys.some((k) => !answers.has(k))) {
-      report.skip(path, `it holds a value nobody has answered for: run \`${hint}\` in a terminal`);
+      report.wait(path, `it holds a value nobody has answered for: run \`${hint}\` in a terminal`);
     } else {
-      report.skip(path, `it holds a value to rewrite as its identifier or ~: run \`${hint}\` in a terminal`);
+      report.wait(path, `it holds a value to rewrite as its identifier or ~: run \`${hint}\` in a terminal`);
     }
   }
   for (const g of groups) {
@@ -3635,12 +3718,11 @@ async function people(opts, ws, files, report, hint) {
   }
   return { files: current, held, leftOut };
 }
+async function removeLeftTemps(dir, temps) {
+  for (const rel of temps) await rm3(toPath(dir, rel), { force: true });
+}
 async function applyPlan(dir, plan) {
-  for (const [path, text3] of Object.entries(plan.writes)) {
-    const full = toPath(dir, path);
-    await mkdir3(dirname3(full), { recursive: true });
-    await writeFile3(full, text3, "utf8");
-  }
+  for (const [path, text3] of Object.entries(plan.writes)) await writeWhole(toPath(dir, path), text3);
   for (const path of plan.deletes) await rm3(toPath(dir, path), { force: true });
 }
 var sameManifest = (a, b) => Object.keys(a).length === Object.keys(b).length && Object.entries(a).every(([p, h]) => b[p] === h);
@@ -3685,8 +3767,19 @@ async function syncMemory(opts) {
   const { client, out } = opts;
   const now = opts.now?.() ?? /* @__PURE__ */ new Date();
   try {
+    const checkDeadline = () => {
+      if (opts.deadline !== void 0 && Date.now() > opts.deadline) {
+        throw new SyncStopped("took too long", "Stopped: the sync's time ran out before anything more was written or sent.");
+      }
+    };
     const own = await client.getOwnTeamSetup();
     const ws = own.workspace;
+    if (opts.workspace && ws !== opts.workspace) {
+      throw new SyncStopped(
+        "the key is for another workspace",
+        `The key is for ${ws}, not ${opts.workspace}: nothing was synced. Set SYSTEMDOX_API_KEY to a key of ${opts.workspace}, or unset it.`
+      );
+    }
     const project = opts.project ?? (own.memory.length === 1 ? own.memory[0].project : void 0);
     if (!project) {
       throw new SyncFailed(
@@ -3700,6 +3793,12 @@ async function syncMemory(opts) {
     const date = localDate(now);
     const stored = (await readState(ws)).memory?.[project];
     let team = await pullTeam(client, ws, project);
+    if (opts.unattended && stored && !team.exists) {
+      throw new SyncStopped(
+        "the team memory could not be read",
+        `${ws}/${project} could not be read from SystemDox: nothing was changed. Run sync-memory in your terminal to see why.`
+      );
+    }
     let base = stored ? { version: stored.version, manifest: stored.manifest, exists: true } : { version: 0, manifest: {}, exists: false };
     const folder = await readFolder(dir);
     const shared = {};
@@ -3712,14 +3811,16 @@ async function syncMemory(opts) {
       } else shared[path] = text3;
     }
     const importWrites = {};
-    if (opts.importDir) {
-      const other = await readFolder(resolve3(opts.importDir));
-      const taken = new Set(folder.names);
+    const current = { ...folder.files };
+    const taken = new Set(folder.names);
+    for (const importDir of opts.importDirs ?? []) {
+      const other = await readFolder(resolve3(importDir));
       for (const [path, text3] of Object.entries(other.files).sort(([a], [b]) => a.localeCompare(b))) {
         if (!isShareable(path, text3) || !isFilePath(path)) continue;
-        const here = folder.files[path];
+        const here = current[path];
         if (here === void 0) {
           shared[path] = text3;
+          current[path] = text3;
           importWrites[path] = text3;
           taken.add(path.toLowerCase());
         } else if (here !== text3) {
@@ -3727,16 +3828,14 @@ async function syncMemory(opts) {
           taken.add(copy.toLowerCase());
           importWrites[copy] = text3;
           report.conflicts.push(`${path}: this folder's text; the imported one is beside it as ${copy}`);
+          report.copies.add(copy);
         }
       }
-      folder.names = taken;
-      if (!opts.dryRun) {
-        for (const [path, text3] of Object.entries(importWrites)) {
-          const full = toPath(dir, path);
-          await mkdir3(dirname3(full), { recursive: true });
-          await writeFile3(full, text3, "utf8");
-        }
-      }
+    }
+    folder.names = taken;
+    if (!opts.dryRun) {
+      checkDeadline();
+      for (const [path, text3] of Object.entries(importWrites)) await writeWhole(toPath(dir, path), text3);
     }
     const found = await people(run2, ws, shared, report, hint);
     for (const path of found.leftOut) {
@@ -3761,12 +3860,16 @@ async function syncMemory(opts) {
         );
         return 0;
       }
+      checkDeadline();
+      if (attempt === 1) await removeLeftTemps(dir, folder.temps);
       await applyPlan(dir, plan);
       let version = team.version;
       if (!sameManifest(plan.manifest, team.manifest)) {
+        checkDeadline();
         await upload(client, ws, project, plan, team.manifest, report);
       }
       if (!sameManifest(plan.manifest, team.manifest)) {
+        checkDeadline();
         try {
           version = (await client.pushMemoryVersion(ws, project, { baseVersion: team.version, manifest: plan.manifest })).version;
         } catch (e) {
@@ -3778,6 +3881,7 @@ async function syncMemory(opts) {
                 false
               )
             );
+            opts.summary?.(report.summary("moved-on", team.version, "moved on twice"));
             return 2;
           }
           base = team;
@@ -3802,10 +3906,21 @@ async function syncMemory(opts) {
           false
         )
       );
+      opts.summary?.(report.summary("synced", version));
       return 0;
     }
   } catch (e) {
     out(e.message);
+    opts.summary?.({
+      outcome: "failed",
+      reason: failureReason(e),
+      version: 0,
+      pulled: 0,
+      pushed: 0,
+      deleted: 0,
+      conflictCopies: [],
+      waiting: []
+    });
     return 1;
   }
 }
@@ -3977,7 +4092,9 @@ function registerTeamSetupTools(server, apiClient, { localFiles }) {
         project: args.project,
         dryRun: !!args.dryRun,
         client: apiClient,
-        out: (...l) => lines.push(...l)
+        out: (...l) => lines.push(...l),
+        // Nobody is at a terminal: a project the team no longer serves is left as it is.
+        unattended: true
       });
       return { ...text2(lines.join("\n")), ...code ? { isError: true } : {} };
     }
@@ -3985,7 +4102,7 @@ function registerTeamSetupTools(server, apiClient, { localFiles }) {
 }
 
 // src/server.ts
-var SERVER_VERSION = true ? "0.1.57" : "0.0.0-dev";
+var SERVER_VERSION = true ? "0.1.58" : "0.0.0-dev";
 var READ_TOOLS = [
   "get_context",
   "get_checks",