@systemdox/mcp-server 0.1.57 → 0.1.58

package/dist/sync-memory.js

@@ -2,7 +2,7 @@
 
 // src/sync-memory.ts
 import { existsSync } from "fs";
-import { mkdir as mkdir2, readdir, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { appendFile, mkdir as mkdir2, open, readdir, readFile as readFile2, rename as rename2, rm as rm2, stat, writeFile as writeFile2 } from "fs/promises";
 import { dirname as dirname2, join as join2, resolve } from "path";
 
 // src/lib/cache.ts
@@ -349,15 +349,41 @@ function readFrontmatter(text) {
   const m = BLOCK_RE.exec(text);
   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, text) {
@@ -644,6 +670,12 @@ function workspaceDir(workspace) {
 function statePath(workspace) {
   return join(workspaceDir(workspace), "state.json");
 }
+function syncLogPath(workspace) {
+  return join(workspaceDir(workspace), "sync-memory.log");
+}
+function syncLockPath(workspace) {
+  return join(workspaceDir(workspace), "sync.lock");
+}
 async function readJson(path, empty) {
   let text;
   try {
@@ -668,6 +700,11 @@ async function readCredentials() {
   return readJson(credentialsPath(), {});
 }
 var run = promisify(execFile);
+async function apiKeyFor(workspace, env = process.env) {
+  if (env.SYSTEMDOX_API_KEY) return env.SYSTEMDOX_API_KEY;
+  const entry = (await readCredentials())[workspace];
+  return typeof entry?.apiKey === "string" && entry.apiKey ? entry.apiKey : void 0;
+}
 async function localApiKey(env = process.env) {
   if (env.SYSTEMDOX_API_KEY) return env.SYSTEMDOX_API_KEY;
   const keys = Object.entries(await readCredentials()).filter(
@@ -706,38 +743,79 @@ async function updateState(workspace, change) {
 }
 
 // src/sync-memory.ts
-var SYNC_MEMORY_USAGE = "Usage: systemdox-mcp-server sync-memory [--project <name>] [--dir <folder>] [--import <folder>] [--dry-run]";
+var SYNC_MEMORY_USAGE = "Usage: systemdox-mcp-server sync-memory [--project <name>] [--dir <folder>] [--import <folder>]... [--dry-run]\n       systemdox-mcp-server sync-memory --hook <workspace>";
+var HOOK_BUDGET_MS = 2e4;
+var HOOK_LOCK_STALE_MS = 6e4;
+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, text) {
+  await mkdir2(dirname2(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  try {
+    await writeFile2(tmp, text, "utf8");
+    await rename2(tmp, path);
+  } catch (e) {
+    await rm2(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 };
 }
 function parseSyncMemoryArgs(argv) {
-  const args = { dryRun: false };
+  const args = { dryRun: false, importDirs: [] };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === "--dry-run") args.dryRun = true;
-    else if (a === "--project" || a === "--dir" || a === "--import") {
+    else if (a === "--project" || a === "--dir" || a === "--import" || a === "--hook") {
       const value = argv[++i];
       if (!value || value.startsWith("--")) throw new SyncFailed(`${a} needs a value
 ${SYNC_MEMORY_USAGE}`);
       if (a === "--project") {
         if (!isWorkspace(value)) throw new SyncFailed(`${value} is not a project name (lower case letters, digits and -)`);
         args.project = value;
+      } else if (a === "--hook") {
+        if (!isWorkspace(value)) throw new SyncFailed(`${value} is not a workspace name (lower case letters, digits and -)`);
+        args.hook = value;
       } else if (a === "--dir") args.dir = value;
-      else args.importDir = value;
+      else args.importDirs.push(value);
     } else throw new SyncFailed(`Unexpected argument ${a}
+${SYNC_MEMORY_USAGE}`);
+  }
+  if (args.hook && (args.project || args.dir || args.importDirs.length || args.dryRun)) {
+    throw new SyncFailed(`--hook takes no other option
 ${SYNC_MEMORY_USAGE}`);
   }
   return args;
 }
 var toPath = (root, rel) => join2(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 walk(dir, prefix) {
     for (const e of await readdir(dir, { withFileTypes: true })) {
       if (e.name.startsWith(".")) continue;
@@ -745,12 +823,13 @@ async function readFolder(root) {
       if (e.isDirectory()) await walk(join2(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 readFile2(join2(dir, e.name), "utf8");
       }
     }
   }
   if (existsSync(root)) await walk(root, "");
-  return { files, names };
+  return { files, names, temps };
 }
 async function pullTeam(client, ws, project) {
   try {
@@ -799,7 +878,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) {
@@ -807,12 +890,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) => {
@@ -915,7 +1018,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 writeFile2(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 });
@@ -1018,7 +1121,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 writeFile2(toPath(opts.dir, path), rewritten[path], "utf8");
+        await writeWhole(toPath(opts.dir, path), rewritten[path]);
         current[path] = rewritten[path];
       }
     }
@@ -1033,11 +1136,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) {
@@ -1048,12 +1151,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 rm2(toPath(dir, rel), { force: true });
+}
 async function applyPlan(dir, plan) {
-  for (const [path, text] of Object.entries(plan.writes)) {
-    const full = toPath(dir, path);
-    await mkdir2(dirname2(full), { recursive: true });
-    await writeFile2(full, text, "utf8");
-  }
+  for (const [path, text] of Object.entries(plan.writes)) await writeWhole(toPath(dir, path), text);
   for (const path of plan.deletes) await rm2(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);
@@ -1098,8 +1200,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(
@@ -1113,6 +1226,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 = {};
@@ -1125,14 +1244,16 @@ async function syncMemory(opts) {
       } else shared[path] = text;
     }
     const importWrites = {};
-    if (opts.importDir) {
-      const other = await readFolder(resolve(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(resolve(importDir));
       for (const [path, text] of Object.entries(other.files).sort(([a], [b]) => a.localeCompare(b))) {
         if (!isShareable(path, text) || !isFilePath(path)) continue;
-        const here = folder.files[path];
+        const here = current[path];
         if (here === void 0) {
           shared[path] = text;
+          current[path] = text;
           importWrites[path] = text;
           taken.add(path.toLowerCase());
         } else if (here !== text) {
@@ -1140,16 +1261,14 @@ async function syncMemory(opts) {
           taken.add(copy.toLowerCase());
           importWrites[copy] = text;
           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, text] of Object.entries(importWrites)) {
-          const full = toPath(dir, path);
-          await mkdir2(dirname2(full), { recursive: true });
-          await writeFile2(full, text, "utf8");
-        }
-      }
+    }
+    folder.names = taken;
+    if (!opts.dryRun) {
+      checkDeadline();
+      for (const [path, text] of Object.entries(importWrites)) await writeWhole(toPath(dir, path), text);
     }
     const found = await people(run2, ws, shared, report, hint);
     for (const path of found.leftOut) {
@@ -1174,12 +1293,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) {
@@ -1191,6 +1314,7 @@ async function syncMemory(opts) {
                 false
               )
             );
+            opts.summary?.(report.summary("moved-on", team.version, "moved on twice"));
             return 2;
           }
           base = team;
@@ -1215,18 +1339,198 @@ 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;
   }
 }
+var plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+function hookLines(ws, project, folder, s) {
+  if (s.outcome !== "synced") {
+    return [`Team memory ${ws}/${project}: not synced (${s.reason ?? "it did not finish"}); your files are unchanged and the next session tries again.`];
+  }
+  const lines = [`Team memory ${ws}/${project}: version ${s.version}, ${s.pulled} pulled, ${s.pushed} pushed, ${s.deleted} deleted.`];
+  if (s.conflictCopies.length) {
+    lines.push(`  ${plural(s.conflictCopies.length, "conflict copy", "conflict copies")} to tidy in ${folder}: ${s.conflictCopies.join(", ")}`);
+  }
+  if (s.waiting.length) {
+    lines.push(
+      `  ${plural(s.waiting.length, "file waits", "files wait")} for you: run \`${SYNC_MEMORY_COMMAND} --project ${project}\` in your terminal.`
+    );
+  }
+  return lines;
+}
+async function appendLog(ws, lines) {
+  const path = syncLogPath(ws);
+  await mkdir2(dirname2(path), { recursive: true });
+  try {
+    if ((await stat(path)).size > HOOK_LOG_MAX_BYTES) await writeFile2(path, "", "utf8");
+  } catch {
+  }
+  await appendFile(path, lines.join("\n") + "\n", "utf8");
+}
+async function takeLock(lock, staleMs, now) {
+  await mkdir2(dirname2(lock), { recursive: true });
+  const body = JSON.stringify({ pid: process.pid, at: now.toISOString() }) + "\n";
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const handle = await open(lock, "wx");
+      try {
+        await handle.writeFile(body, "utf8");
+      } catch (err) {
+        await handle.close();
+        await rm2(lock, { force: true });
+        throw err;
+      }
+      await handle.close();
+      return true;
+    } catch (e) {
+      if (e.code !== "EEXIST") throw e;
+      let seen;
+      try {
+        seen = await stat(lock);
+      } catch {
+        continue;
+      }
+      if (Date.now() - seen.mtimeMs < staleMs || attempt === 1) return false;
+      try {
+        const now2 = await stat(lock);
+        if (now2.ino !== seen.ino || now2.mtimeMs !== seen.mtimeMs) return false;
+      } catch {
+        continue;
+      }
+      await rm2(lock, { force: true });
+    }
+  }
+  return false;
+}
+async function releaseLock(lock) {
+  try {
+    const held = JSON.parse(await readFile2(lock, "utf8"));
+    if (held.pid === process.pid) await rm2(lock, { force: true });
+  } catch {
+  }
+}
+async function runHookSync(workspace, io, env = process.env) {
+  try {
+    return await hookSync(workspace, io, env);
+  } catch (e) {
+    try {
+      io.err(`sync-memory --hook: ${e.message}`);
+    } catch {
+    }
+    return 0;
+  }
+}
+async function hookSync(workspace, io, env) {
+  if (!isWorkspace(workspace)) {
+    io.err(`sync-memory --hook: ${JSON.stringify(workspace)} is not a workspace name`);
+    return 0;
+  }
+  const now = io.now?.() ?? /* @__PURE__ */ new Date();
+  const deadline = (io.startedAt ?? Date.now()) + (io.budgetMs ?? HOOK_BUDGET_MS);
+  let client = io.client;
+  if (!client) {
+    let apiKey;
+    let apiUrl;
+    try {
+      apiKey = await apiKeyFor(workspace, env);
+      apiUrl = apiUrlFrom(env);
+    } catch {
+      return 0;
+    }
+    if (!apiKey) return 0;
+    client = new SystemDoxApiClient({ apiKey, apiUrl, cacheTtlMs: 0, defaultOrg: void 0 });
+  }
+  let projects;
+  try {
+    projects = Object.keys((await readState(workspace)).memory ?? {}).sort();
+  } catch {
+    return 0;
+  }
+  if (!projects.length) return 0;
+  const lock = syncLockPath(workspace);
+  if (!await takeLock(lock, io.lockStaleMs ?? HOOK_LOCK_STALE_MS, now)) {
+    io.out(`Team memory ${workspace}: a sync is already running.`);
+    return 0;
+  }
+  try {
+    for (const project of projects) {
+      const folder = join2(workspaceDir(workspace), "memory", project);
+      const report = [];
+      let summary;
+      const left = deadline - Date.now();
+      if (left > 0) {
+        let timer;
+        const timeout = new Promise((resolveTimeout) => {
+          timer = setTimeout(() => resolveTimeout("timeout"), left);
+        });
+        const run2 = syncMemory({
+          project,
+          dryRun: false,
+          client,
+          workspace,
+          deadline,
+          unattended: true,
+          out: (...lines2) => report.push(...lines2),
+          summary: (s) => summary = s,
+          now: io.now
+        });
+        const won = await Promise.race([run2.then(() => "done"), timeout]);
+        if (timer) clearTimeout(timer);
+        if (won === "timeout") summary = void 0;
+      }
+      const result = summary ?? {
+        outcome: "failed",
+        reason: "took too long",
+        version: 0,
+        pulled: 0,
+        pushed: 0,
+        deleted: 0,
+        conflictCopies: [],
+        waiting: []
+      };
+      const lines = hookLines(workspace, project, folder, result);
+      lines.forEach((l) => io.out(l));
+      try {
+        await appendLog(workspace, [`--- ${now.toISOString()} ${workspace}/${project}`, ...lines, ...report]);
+      } catch (e) {
+        io.err(`sync-memory --hook: the log could not be written: ${e.message}`);
+      }
+    }
+  } finally {
+    await releaseLock(lock);
+  }
+  return 0;
+}
 async function runSyncMemory(argv, io, env = process.env) {
   let args;
   let client = io.client;
   try {
     args = parseSyncMemoryArgs(argv);
+  } catch (e) {
+    if (argv.includes("--hook")) {
+      io.err(`sync-memory --hook: ${e.message.split("\n")[0]}`);
+      return 0;
+    }
+    io.err(e.message);
+    return 1;
+  }
+  if (args.hook) return runHookSync(args.hook, io, env);
+  try {
     if (!client) {
       const apiUrl = apiUrlFrom(env);
       const apiKey = await localApiKey(env);
@@ -1239,9 +1543,14 @@ async function runSyncMemory(argv, io, env = process.env) {
   return syncMemory({ ...args, client, out: (...lines) => lines.forEach((l) => io.out(l)), ask: io.ask, now: io.now });
 }
 export {
+  HOOK_BUDGET_MS,
+  HOOK_LOCK_STALE_MS,
+  HOOK_LOG_MAX_BYTES,
   SYNC_MEMORY_COMMAND,
   SYNC_MEMORY_USAGE,
+  hookLines,
   parseSyncMemoryArgs,
+  runHookSync,
   runSyncMemory,
   syncMemory
 };