threadnote 0.7.8 → 0.7.10

package/README.md

@@ -342,6 +342,9 @@ This is it! Start working with your agents as usual. The agent will automaticall
 - `version`: prints the installed Threadnote version, latest npm version, and release notes for newer GitHub releases.
 - `update`: updates the published Threadnote package, then runs `repair` so shims and MCP config point at the new
   version. When an update is available, it prints release notes for the full version diff.
+- `manage`: opens the local React web manager for browsing, recalling, reading, editing, archiving, forgetting,
+  publishing, consolidating, and diagnosing local/shared memories. It binds to `127.0.0.1` with a per-session token; use
+  `--no-open` to print the URL without opening a browser.
 - `repair`: fixes install/config/shim/manifest/server health issues and rewrites Codex/Claude/Cursor/Copilot MCP configs
   from the current checkout.
 - `start`: starts `openviking-server` on `127.0.0.1:1933`.
@@ -377,7 +380,7 @@ This is it! Start working with your agents as usual. The agent will automaticall
   succeeds.
 - `forget`: removes a `viking://` URI.
 - `export-pack` / `import-pack`: moves local context through `.ovpack` files.
-- `share init|status|sync|publish|unpublish|list|remove`: opts a curated subset of durable memories into a team git
+- `share init|status|sync|publish|unpublish|list|rename|set-url|remove`: opts a curated subset of durable memories into a team git
   repo. Threadnote periodically fetches configured share repos and automatically syncs clean incoming changes before
   agent recall/read; use `share sync` for dirty worktrees, conflicts, explicit pushes, or immediate manual sync.
   Personal handoffs and preferences stay local. See `docs/share.md` for the full workflow and the publish-time scrubber

package/dist/mcp_server.cjs

@@ -33691,33 +33691,111 @@ async function runCommand(executable, args, options = {}) {
     const child = (0, import_node_child_process.spawn)(executable, args, { cwd: options.cwd });
     const stdoutChunks = [];
     const stderrChunks = [];
+    const maxOutputBytes = options.maxOutputBytes ?? defaultCommandMaxOutputBytes();
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let finished = false;
+    let failureResult;
+    let killTimer;
+    let sentTerminationSignal = false;
+    const timeoutMs = options.timeoutMs ?? defaultCommandTimeoutMs();
+    const finish = (result) => {
+      if (finished) {
+        return;
+      }
+      finished = true;
+      if (killTimer) {
+        clearTimeout(killTimer);
+      }
+      if (result.exitCode !== 0 && options.allowFailure !== true) {
+        rejectPromise(new Error(`${formatShellCommand(executable, args)} failed: ${result.stderr || result.stdout}`));
+        return;
+      }
+      resolvePromise(result);
+    };
+    const failAndKill = (message) => {
+      if (failureResult) {
+        return;
+      }
+      failureResult = { exitCode: 124, stderr: message, stdout: stdoutChunks.join("") };
+      if (!sentTerminationSignal) {
+        sentTerminationSignal = true;
+        child.kill("SIGTERM");
+      }
+      setTimeout(() => {
+        if (!finished) {
+          child.kill("SIGKILL");
+        }
+      }, 1e3).unref?.();
+    };
+    if (timeoutMs > 0) {
+      killTimer = setTimeout(() => {
+        failAndKill(`${formatShellCommand(executable, args)} timed out after ${timeoutMs}ms`);
+      }, timeoutMs);
+      killTimer.unref?.();
+    }
     child.stdout.on("data", (chunk) => {
-      stdoutChunks.push(String(chunk));
+      if (failureResult) {
+        return;
+      }
+      const text = String(chunk);
+      stdoutBytes += Buffer.byteLength(text);
+      if (stdoutBytes + stderrBytes > maxOutputBytes) {
+        failAndKill(`${formatShellCommand(executable, args)} exceeded output limit of ${maxOutputBytes} bytes`);
+        return;
+      }
+      stdoutChunks.push(text);
     });
     child.stderr.on("data", (chunk) => {
-      stderrChunks.push(String(chunk));
+      if (failureResult) {
+        return;
+      }
+      const text = String(chunk);
+      stderrBytes += Buffer.byteLength(text);
+      if (stdoutBytes + stderrBytes > maxOutputBytes) {
+        failAndKill(`${formatShellCommand(executable, args)} exceeded output limit of ${maxOutputBytes} bytes`);
+        return;
+      }
+      stderrChunks.push(text);
     });
     child.on("error", (err) => {
+      if (finished) {
+        return;
+      }
+      if (killTimer) {
+        clearTimeout(killTimer);
+      }
       if (options.allowFailure === true) {
-        resolvePromise({ exitCode: 127, stderr: errorMessage(err), stdout: "" });
+        finish({ exitCode: 127, stderr: errorMessage(err), stdout: "" });
       } else {
+        finished = true;
         rejectPromise(err);
       }
     });
     child.on("close", (code) => {
-      const result = {
+      const result = failureResult ?? {
         exitCode: code ?? 1,
         stderr: stderrChunks.join(""),
         stdout: stdoutChunks.join("")
       };
-      if (result.exitCode !== 0 && options.allowFailure !== true) {
-        rejectPromise(new Error(`${formatShellCommand(executable, args)} failed: ${result.stderr || result.stdout}`));
-        return;
-      }
-      resolvePromise(result);
+      finish(result);
     });
   });
 }
+function defaultCommandTimeoutMs() {
+  return positiveIntegerFromEnv("THREADNOTE_COMMAND_TIMEOUT_MS") ?? 10 * 60 * 1e3;
+}
+function defaultCommandMaxOutputBytes() {
+  return positiveIntegerFromEnv("THREADNOTE_COMMAND_MAX_OUTPUT_BYTES") ?? 5 * 1024 * 1024;
+}
+function positiveIntegerFromEnv(name) {
+  const value = process.env[name];
+  if (value === void 0) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
 async function gitValue(args, cwd = getInvocationCwd()) {
   const result = await runCommand("git", args, { allowFailure: true, cwd });
   if (result.exitCode !== 0) {
@@ -34671,6 +34749,58 @@ async function runShareSyncQuiet(config2, state, options) {
   }
   return void 0;
 }
+async function publishShareGitChange(worktree, relativePath, commitMessage, options = {}) {
+  const dryRun = options.dryRun === true;
+  const push = options.push !== false;
+  const verb = options.verb ?? "add";
+  const git = await requiredExecutable("git");
+  const messages = [];
+  const stageArgs = verb === "rm" ? ["-C", worktree, "rm", relativePath] : ["-C", worktree, "add", "--", relativePath];
+  const stageResult = await runGitCommand(dryRun, git, stageArgs, `git ${verb} failed`);
+  if (stageResult) {
+    messages.push(`git ${verb}: ${stageResult.stdout.trim() || "ok"}`);
+  }
+  if (dryRun) {
+    console.log(`Would run: ${formatShellCommand(git, ["-C", worktree, "commit", "-m", commitMessage])}`);
+  } else {
+    const commitResult = await runCommand(git, ["-C", worktree, "commit", "-m", commitMessage], { allowFailure: true });
+    if (commitResult.exitCode !== 0) {
+      const detail = commitResult.stdout.trim() || commitResult.stderr.trim();
+      if (/nothing to commit|no changes added/i.test(detail)) {
+        messages.push("git commit: nothing to commit (file already in tree)");
+      } else {
+        throw new Error(`git commit failed: ${detail || "unknown error"}`);
+      }
+    } else {
+      messages.push(`git commit: ${commitResult.stdout.trim().split("\n").slice(0, 2).join(" ")}`);
+    }
+  }
+  if (!push) {
+    messages.push("git push skipped (push=false)");
+    return messages;
+  }
+  const pushResult = await runGitCommand(
+    dryRun,
+    git,
+    ["-C", worktree, "push", DEFAULT_GIT_REMOTE_NAME],
+    "git push failed"
+  );
+  if (pushResult) {
+    messages.push(`git push: ${pushResult.stdout.trim() || pushResult.stderr.trim() || "ok"}`);
+  }
+  return messages;
+}
+async function runGitCommand(dryRun, git, args, failureLabel) {
+  if (dryRun) {
+    console.log(`Would run: ${formatShellCommand(git, args)}`);
+    return void 0;
+  }
+  const result = await runCommand(git, args, { allowFailure: true });
+  if (result.exitCode !== 0) {
+    throw new Error(`${failureLabel}: ${result.stderr.trim() || result.stdout.trim() || "unknown error"}`);
+  }
+  return result;
+}
 function normalizeTeamName(input) {
   const candidate = (input ?? "default").trim();
   if (!candidate) {
@@ -34965,47 +35095,6 @@ async function ingestSingleFile(ov, config2, uri, filePath, initialMode, options
   const content = await (0, import_promises3.readFile)(filePath, "utf8");
   await writeMemoryFile(config2, ov, uri, content, initialMode, false, options);
 }
-async function removeWithRollback(config2, ov, sourceUri, rollbackUri, worktree, dryRun, label) {
-  try {
-    await removeMemoryUri(config2, ov, sourceUri, dryRun);
-  } catch (sourceErr) {
-    if (dryRun) {
-      throw sourceErr;
-    }
-    console.error(
-      `Source removal failed during ${label}; rolling back ${rollbackUri} so the system is back to the pre-${label} state.`
-    );
-    try {
-      await removeMemoryUri(config2, ov, rollbackUri, false);
-    } catch (rollbackErr) {
-      console.error(
-        `Rollback of ${rollbackUri} also failed. Manual cleanup needed via: threadnote forget ${rollbackUri}
-Rollback error: ${rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr)}`
-      );
-    }
-    await bestEffortRemoveWorktreeFile(rollbackUri, worktree, label);
-    throw sourceErr;
-  }
-}
-async function bestEffortRemoveWorktreeFile(rollbackUri, worktree, label) {
-  if (label !== "publish") {
-    return;
-  }
-  const prefix = "viking://";
-  if (!rollbackUri.startsWith(prefix)) {
-    return;
-  }
-  const parts = rollbackUri.slice(prefix.length).split("/");
-  const sharedIndex = parts.indexOf("shared");
-  if (sharedIndex === -1 || sharedIndex + 2 >= parts.length) {
-    return;
-  }
-  const relative2 = parts.slice(sharedIndex + 2).join("/");
-  if (!relative2) {
-    return;
-  }
-  await (0, import_promises3.rm)((0, import_node_path3.join)(worktree, relative2), { force: true });
-}
 async function removeMemoryUri(config2, ov, uri, dryRun, options = {}) {
   const args = withIdentity(config2, ["rm", uri]);
   if (dryRun) {
@@ -35167,7 +35256,7 @@ async function main() {
         "During feature work, update durable feature knowledge when valuable implementation details, decisions, interfaces, or gotchas change.",
         "When updating the same active issue, pass project/topic or replaceUri to remember_context so duplicate durable memories or handoffs do not accumulate.",
         "Use compact_context with dryRun=true for scoped memory hygiene when recall surfaces overlapping active memories.",
-        "To share a durable memory with teammates, call `share_publish` with its viking:// URI. share_publish is destructive: it scrubs for secrets, moves the memory into the shared subtree, removes the personal copy, and pushes a git commit. Do not publish handoffs, preferences, or anything carrying machine-local paths or in-flight task context.",
+        "To share a durable memory with teammates, call `share_publish` with its viking:// URI. share_publish scrubs for secrets, writes and pushes the shared copy first, then removes the personal copy after the push succeeds. Do not publish handoffs, preferences, or anything carrying machine-local paths or in-flight task context.",
         "Do not store secrets, customer data, raw production logs, or credentials."
       ].join("\n")
     }
@@ -35351,7 +35440,7 @@ function registerTools(server, config2) {
     "share_publish",
     {
       annotations: { readOnlyHint: false, destructiveHint: true },
-      description: "Publish a personal memory into a team's shared memories git repo. Reads the memory, strips local-only provenance frontmatter (supersedes:, archived_from:), refuses publish if it matches secret patterns, copies it into the shared subtree, removes the personal original, and commits/pushes. Default team is used unless team is provided. Pass preview=true to return the would-be-published bytes without writing or committing.",
+      description: "Publish a personal memory into a team's shared memories git repo. Reads the memory, strips local-only provenance frontmatter (supersedes:, archived_from:), refuses publish if it matches secret patterns, writes and pushes the shared copy first, then removes the personal original. Default team is used unless team is provided. Pass preview=true to return the would-be-published bytes without writing or committing.",
       inputSchema: {
         message: external_exports.string().optional().describe('Commit message override; defaults to "share: publish <path>"'),
         preview: external_exports.boolean().optional().describe(
@@ -35749,27 +35838,8 @@ function registerCompactTool(server, config2) {
         const ov = await requiredOpenVikingCli2();
         const appliedMessages = [];
         for (const action of plan.keepUpdates) {
-          const result = await runOpenVikingWriteWithRetry(
-            ov,
-            config2,
-            action.uri,
-            withIdentity2(config2, [
-              "write",
-              action.uri,
-              "--content",
-              action.content,
-              "--mode",
-              "replace",
-              "--wait",
-              "--timeout",
-              "120"
-            ])
-          );
+          await writeMemoryFile(config2, ov, action.uri, action.content, "replace", false, { quiet: true });
           appliedMessages.push(`Updated kept memory: ${action.uri}`);
-          const output = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
-          if (output) {
-            appliedMessages.push(output);
-          }
         }
         for (const action of plan.archives) {
           const archiveResult = await archiveMemoryForCompact(config2, ov, action);
@@ -35942,22 +36012,7 @@ async function writeDurableMemory(config2, params) {
     const finalMetadata = isInPlaceUpdate ? { ...params.metadata, supersedes: void 0 } : candidateMetadata;
     const memory = isInPlaceUpdate ? formatMemoryDocument2("MEMORY", finalMetadata, params.bodyText) : candidateMemory;
     const writeMode = await memoryWriteMode(ov, config2, memoryUri, finalMetadata);
-    const result = await runOpenVikingWriteWithRetry(
-      ov,
-      config2,
-      memoryUri,
-      withIdentity2(config2, [
-        "write",
-        memoryUri,
-        "--content",
-        memory,
-        "--mode",
-        writeMode,
-        "--wait",
-        "--timeout",
-        "120"
-      ])
-    );
+    await writeMemoryFile(config2, ov, memoryUri, memory, writeMode, false, { quiet: true });
     const messages = [`Stored memory: ${memoryUri}`];
     if (params.replaceUri && !isInPlaceUpdate) {
       const removedReplacedMemory = await removeVikingResourceWithRetry(ov, config2, params.replaceUri);
@@ -35967,8 +36022,7 @@ async function writeDurableMemory(config2, params) {
     } else if (isInPlaceUpdate) {
       messages.push(`Updated existing memory in place: ${memoryUri}`);
     }
-    const text = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
-    return { content: [{ type: "text", text: [...messages, text].filter(Boolean).join("\n") }] };
+    return { content: [{ type: "text", text: messages.join("\n") }] };
   } catch (err) {
     return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
   }
@@ -36003,27 +36057,10 @@ async function writeSharedMemoryReplacement(config2, ov, params, targetUri) {
     messages.push(`Redacted ${redaction.count}\xD7 ${redaction.name} before shared update.`);
   }
   messages.push(
-    ...await gitPublishWorkflow(resolved.config.worktree, relativePath, `share: update ${relativePath}`, true)
+    ...await publishShareGitChange(resolved.config.worktree, relativePath, `share: update ${relativePath}`)
   );
   return { content: [{ type: "text", text: messages.join("\n") }] };
 }
-async function runOpenVikingWriteWithRetry(ov, config2, memoryUri, args) {
-  for (let attempt = 0; attempt < 4; attempt += 1) {
-    const result = await runCommand(ov, args, { allowFailure: true });
-    if (result.exitCode === 0) {
-      return result;
-    }
-    if (await vikingResourceExists2(ov, config2, memoryUri)) {
-      await runCommand(ov, withIdentity2(config2, ["wait", "--timeout", "120"]), { allowFailure: true });
-      return { exitCode: 0, stdout: "OpenViking accepted the memory and indexing wait completed.", stderr: "" };
-    }
-    if (!isResourceBusy(result.stderr, result.stdout) || attempt === 3) {
-      throw new Error(`${ov} ${args.join(" ")} failed: ${result.stderr || result.stdout}`);
-    }
-    await sleep(1e3 * (attempt + 1));
-  }
-  throw new Error(`${ov} ${args.join(" ")} failed.`);
-}
 async function vikingResourceExists2(ov, config2, uri) {
   const stat2 = await runCommand(ov, withIdentity2(config2, ["stat", uri]), { allowFailure: true });
   return stat2.exitCode === 0;
@@ -36251,17 +36288,27 @@ async function runSharePublishTool(config2, sourceUri, options) {
     }
     await ensureSharedDirectoryChain(config2, ov, targetUri, false);
     await writeMemoryFile(config2, ov, targetUri, content, "create", false);
+    const messages = [`Published ${sourceUri} -> ${targetUri}`];
+    for (const redaction of scrub.redactions) {
+      messages.push(`Redacted ${redaction.count}\xD7 ${redaction.name} before publish.`);
+    }
+    const relativePath = vikingUriToWorktreeRelative(config2, targetUri, resolved.name);
+    const commitMessage = options.message ?? `share: publish ${relativePath}`;
+    const gitMessages = await publishShareGitChange(resolved.config.worktree, relativePath, commitMessage, {
+      push: options.push
+    });
     try {
-      await removeWithRollback(config2, ov, sourceUri, targetUri, resolved.config.worktree, false, "publish");
+      await removeMemoryUri(config2, ov, sourceUri, false, { quiet: true });
     } catch (sourceErr) {
       return {
         content: [
           {
             type: "text",
             text: [
-              `Refused to leave a half-published state: could not remove ${sourceUri}.`,
-              `Rolled back ${targetUri} so the system is back to the pre-publish state.`,
-              `Retry the publish once OpenViking's queue settles.`,
+              ...messages,
+              ...gitMessages,
+              `Could not remove the personal source after publish: ${sourceUri}.`,
+              `Retry cleanup later with: threadnote forget ${sourceUri}`,
               sourceErr instanceof Error ? sourceErr.message : String(sourceErr)
             ].join("\n")
           }
@@ -36269,18 +36316,6 @@ async function runSharePublishTool(config2, sourceUri, options) {
         isError: true
       };
     }
-    const messages = [`Published ${sourceUri} -> ${targetUri}`];
-    for (const redaction of scrub.redactions) {
-      messages.push(`Redacted ${redaction.count}\xD7 ${redaction.name} before publish.`);
-    }
-    const relativePath = vikingUriToWorktreeRelative(config2, targetUri, resolved.name);
-    const commitMessage = options.message ?? `share: publish ${relativePath}`;
-    const gitMessages = await gitPublishWorkflow(
-      resolved.config.worktree,
-      relativePath,
-      commitMessage,
-      options.push !== false
-    );
     return {
       content: [{ type: "text", text: [...messages, ...gitMessages].join("\n") }],
       isError: false
@@ -36289,38 +36324,6 @@ async function runSharePublishTool(config2, sourceUri, options) {
     return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
   }
 }
-async function gitPublishWorkflow(worktree, relativePath, commitMessage, push) {
-  const messages = [];
-  const add = await runCommand("git", ["-C", worktree, "add", relativePath], { allowFailure: true });
-  if (add.exitCode !== 0) {
-    messages.push(`git add failed: ${add.stderr.trim() || add.stdout.trim()}`);
-    return messages;
-  }
-  const commit = await runCommand("git", ["-C", worktree, "commit", "-m", commitMessage], { allowFailure: true });
-  if (commit.exitCode !== 0) {
-    const detail = commit.stdout.trim() || commit.stderr.trim();
-    if (/nothing to commit|no changes added/i.test(detail)) {
-      messages.push("git commit: nothing to commit (file already in tree)");
-    } else {
-      messages.push(`git commit failed: ${detail}`);
-      return messages;
-    }
-  } else {
-    messages.push(`git commit: ${commit.stdout.trim().split("\n").slice(0, 2).join(" ")}`);
-  }
-  if (!push) {
-    messages.push("git push skipped (push=false)");
-    return messages;
-  }
-  const pushResult = await runCommand("git", ["-C", worktree, "push", DEFAULT_GIT_REMOTE_NAME], { allowFailure: true });
-  const pushDetail = pushResult.stdout.trim() || pushResult.stderr.trim();
-  if (pushResult.exitCode !== 0) {
-    messages.push(`git push failed: ${pushDetail}`);
-  } else {
-    messages.push(`git push: ${pushDetail || "ok"}`);
-  }
-  return messages;
-}
 function withIdentity2(config2, args) {
   return [...args, "--account", config2.account, "--user", config2.user, "--agent-id", config2.agentId];
 }