threadnote 0.7.2 → 0.7.4

package/dist/threadnote.cjs

@@ -3472,7 +3472,7 @@ var {
 // src/constants.ts
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 1933;
-var DEFAULT_OPENVIKING_VERSION = "0.3.12";
+var DEFAULT_OPENVIKING_VERSION = "0.3.21";
 var DEFAULT_ACCOUNT = "local";
 var DEFAULT_AGENT_ID = "threadnote";
 var OPENVIKING_PACKAGE_NAME = "openviking[local-embed]";
@@ -3747,6 +3747,38 @@ async function sleep(ms) {
     setTimeout(resolvePromise, ms);
   });
 }
+function compareVersions(a, b) {
+  const left = parseVersion(a);
+  const right = parseVersion(b);
+  for (let index = 0; index < 3; index += 1) {
+    const difference = left.numbers[index] - right.numbers[index];
+    if (difference !== 0) {
+      return difference;
+    }
+  }
+  if (left.prerelease === right.prerelease) {
+    return 0;
+  }
+  if (left.prerelease === void 0) {
+    return 1;
+  }
+  if (right.prerelease === void 0) {
+    return -1;
+  }
+  return left.prerelease.localeCompare(right.prerelease);
+}
+function parseVersion(version) {
+  const normalized = version.trim().replace(/^v/, "");
+  const [core2, prerelease] = normalized.split("-", 2);
+  const parts = core2.split(".").map((part) => Number(part));
+  return {
+    numbers: [safeVersionNumber(parts[0]), safeVersionNumber(parts[1]), safeVersionNumber(parts[2])],
+    prerelease
+  };
+}
+function safeVersionNumber(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : 0;
+}
 async function readHttpStatus(url, timeoutMs) {
   return new Promise((resolvePromise) => {
     const request = (0, import_node_http.get)(url, (response) => {
@@ -9279,7 +9311,7 @@ async function checkForThreadnoteUpdate(args) {
   }
   const cached = await readUpdateCache(args.cachePath);
   if (cached && isCacheFresh(cached)) {
-    return compareVersions(args.currentVersion, cached.latestVersion);
+    return compareVersions2(args.currentVersion, cached.latestVersion);
   }
   const fresh = await fetchLatestVersion();
   if (fresh) {
@@ -9288,10 +9320,10 @@ async function checkForThreadnoteUpdate(args) {
       latestVersion: fresh,
       version: 1
     });
-    return compareVersions(args.currentVersion, fresh);
+    return compareVersions2(args.currentVersion, fresh);
   }
   if (cached) {
-    return compareVersions(args.currentVersion, cached.latestVersion);
+    return compareVersions2(args.currentVersion, cached.latestVersion);
   }
   return void 0;
 }
@@ -9309,7 +9341,7 @@ function spawnDetachedAutoUpdate() {
   } catch {
   }
 }
-function compareVersions(currentVersion, latestVersion) {
+function compareVersions2(currentVersion, latestVersion) {
   return {
     currentVersion,
     latestVersion,
@@ -9317,8 +9349,8 @@ function compareVersions(currentVersion, latestVersion) {
   };
 }
 function isNewerVersion(candidate, baseline) {
-  const candidateParts = parseVersion(candidate);
-  const baselineParts = parseVersion(baseline);
+  const candidateParts = parseVersion2(candidate);
+  const baselineParts = parseVersion2(baseline);
   for (let index = 0; index < 3; index += 1) {
     if (candidateParts[index] !== baselineParts[index]) {
       return candidateParts[index] > baselineParts[index];
@@ -9326,7 +9358,7 @@ function isNewerVersion(candidate, baseline) {
   }
   return false;
 }
-function parseVersion(value) {
+function parseVersion2(value) {
   const parts = value.split(".").map((part) => parseInt(part, 10));
   return [parts[0] || 0, parts[1] || 0, parts[2] || 0];
 }
@@ -10044,7 +10076,7 @@ async function runUpdate(config, options) {
       console.log(`Update available. Run: threadnote update`);
     } else {
       console.log(
-        compareVersions2(info.currentVersion, info.latestVersion) > 0 ? "Current version is newer than npm latest." : "Threadnote is up to date."
+        compareVersions(info.currentVersion, info.latestVersion) > 0 ? "Current version is newer than npm latest." : "Threadnote is up to date."
       );
     }
     return;
@@ -10091,10 +10123,12 @@ async function runPostUpdate(config, options) {
   if (!options.fromVersion || !options.toVersion) {
     throw new Error("Provide --from-version and --to-version for post-update.");
   }
+  const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true;
+  await ensurePinnedOpenVikingInstalled(config, { dryRun: options.dryRun === true });
   await runApplicablePostUpdateMigrations(config, {
     dryRun: options.dryRun === true,
     fromVersion: options.fromVersion,
-    interactive: process.stdin.isTTY === true && process.stdout.isTTY === true,
+    interactive,
     markHandled: true,
     toVersion: options.toVersion,
     yes: options.yes === true
@@ -10102,6 +10136,8 @@ async function runPostUpdate(config, options) {
 }
 async function maybeRunPostUpdateAfterRepair(config, options) {
   const toVersion = await currentPackageVersion();
+  const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true;
+  await ensurePinnedOpenVikingInstalled(config, { dryRun: options.dryRun });
   const state = await readPostUpdateState(config);
   const migrations = await applicablePostUpdateMigrations(config, {
     fromVersion: "0.0.0",
@@ -10114,7 +10150,7 @@ async function maybeRunPostUpdateAfterRepair(config, options) {
   console.log("");
   console.log("Repair found package post-update migrations.");
   console.log("This also covers updates launched by older Threadnote versions that only knew how to run repair.");
-  if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
+  if (!interactive) {
     console.log(
       "This process is non-interactive, so Threadnote will print the manual migration command instead of prompting."
     );
@@ -10123,12 +10159,110 @@ async function maybeRunPostUpdateAfterRepair(config, options) {
   await runApplicablePostUpdateMigrations(config, {
     dryRun: options.dryRun,
     fromVersion: "0.0.0",
-    interactive: process.stdin.isTTY === true && process.stdout.isTTY === true,
+    interactive,
     markHandled: true,
     toVersion,
     yes: false
   });
 }
+async function ensurePinnedOpenVikingInstalled(config, options) {
+  const ov = await findExecutable(["ov", "openviking"]);
+  if (!ov) {
+    return;
+  }
+  const installedVersion = await readOpenVikingCliVersion(ov);
+  if (!installedVersion) {
+    console.log(`Could not detect OpenViking CLI version via \`${ov} version\`; skipping pinned-version check.`);
+    return;
+  }
+  const pinned = config.openVikingVersion;
+  if (compareVersions(installedVersion, pinned) >= 0) {
+    return;
+  }
+  console.log("");
+  console.log(`Upgrading OpenViking ${installedVersion} -> ${pinned} (pinned by Threadnote).`);
+  console.log("Picks up upstream fixes for share-sync reliability (reindex lock acquisition, ov wait timeout).");
+  const wasRunning = await isOpenVikingHealthy(config);
+  const usingLaunchd = await isLaunchAgentInstalled();
+  const threadnoteCommand = currentThreadnoteCommand() ?? await findExecutable([NPM_PACKAGE_NAME]) ?? NPM_PACKAGE_NAME;
+  await maybeRun(options.dryRun, threadnoteCommand, ["install", "--force", "--no-start"]);
+  if (options.dryRun) {
+    if (wasRunning || usingLaunchd) {
+      console.log("Would restart OpenViking server so the new binary takes effect.");
+    }
+    return;
+  }
+  if (!wasRunning && !usingLaunchd) {
+    return;
+  }
+  console.log("Restarting OpenViking server so the new binary takes effect.");
+  if (usingLaunchd) {
+    const launchAgentPath = launchAgentPlistPath();
+    await runCommand("launchctl", ["unload", launchAgentPath], { allowFailure: true });
+    await runCommand("launchctl", ["load", launchAgentPath], { allowFailure: true });
+  } else {
+    await maybeRun(false, threadnoteCommand, ["stop"]);
+    await maybeRun(false, threadnoteCommand, ["start"]);
+  }
+  const healthyAfter = await waitForOpenVikingHealthy(config, 1e4);
+  if (!healthyAfter) {
+    console.log(
+      `Warning: OpenViking did not return to healthy at ${openVikingHealthEndpoint(config)} within 10s after the restart.`
+    );
+    console.log("Check the server log or run: threadnote start");
+  }
+}
+function openVikingHealthEndpoint(config) {
+  return `http://${config.host}:${config.port}/health`;
+}
+async function isOpenVikingHealthy(config) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => {
+    controller.abort();
+  }, 800);
+  try {
+    const response = await fetch(openVikingHealthEndpoint(config), { signal: controller.signal });
+    return response.ok;
+  } catch (_err) {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function waitForOpenVikingHealthy(config, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await isOpenVikingHealthy(config)) {
+      return true;
+    }
+    await new Promise((resolvePromise) => {
+      setTimeout(resolvePromise, 500);
+    });
+  }
+  return isOpenVikingHealthy(config);
+}
+function launchAgentPlistPath() {
+  return (0, import_node_path10.join)((0, import_node_os5.homedir)(), "Library", "LaunchAgents", "io.threadnote.openviking.plist");
+}
+async function isLaunchAgentInstalled() {
+  if (process.platform !== "darwin") {
+    return false;
+  }
+  try {
+    await (0, import_promises9.access)(launchAgentPlistPath(), import_node_fs5.constants.F_OK);
+    return true;
+  } catch (_err) {
+    return false;
+  }
+}
+async function readOpenVikingCliVersion(ov) {
+  const result = await runCommand(ov, ["version"], { allowFailure: true });
+  if (result.exitCode !== 0) {
+    return void 0;
+  }
+  const match = result.stdout.match(/^\s*CLI:\s*(\S+)/m);
+  return match ? match[1] : void 0;
+}
 async function getUpdateInfo(config, options) {
   const currentVersion = await currentPackageVersion();
   const cached = options.preferFresh ? void 0 : await readFreshCache(config, options.registry);
@@ -10138,7 +10272,7 @@ async function getUpdateInfo(config, options) {
   }
   return {
     currentVersion,
-    isUpdateAvailable: compareVersions2(currentVersion, latestVersion) < 0,
+    isUpdateAvailable: compareVersions(currentVersion, latestVersion) < 0,
     latestVersion,
     registry: options.registry
   };
@@ -10248,10 +10382,10 @@ async function applicablePostUpdateMigrations(config, options) {
     if (handled.has(migration.id)) {
       continue;
     }
-    if (compareVersions2(options.fromVersion, migration.introducedIn) >= 0) {
+    if (compareVersions(options.fromVersion, migration.introducedIn) >= 0) {
       continue;
     }
-    if (compareVersions2(migration.introducedIn, options.toVersion) > 0) {
+    if (compareVersions(migration.introducedIn, options.toVersion) > 0) {
       continue;
     }
     if (migration.requiresLegacyHandoffs === true && !await hasLegacyLifecycleHandoffCandidates(config)) {
@@ -10300,10 +10434,13 @@ function printPostUpdateMigration(migration) {
     console.log(`- ${line}`);
   }
 }
-async function confirmPostUpdateMigration(prompt) {
+async function confirmPostUpdateMigration(prompt, defaultYes = false) {
   const readline = (0, import_promises10.createInterface)({ input: import_node_process.stdin, output: import_node_process.stdout });
   try {
     const answer = (await readline.question(prompt)).trim().toLowerCase();
+    if (answer === "") {
+      return defaultYes;
+    }
     return answer === "y" || answer === "yes";
   } finally {
     readline.close();
@@ -10419,38 +10556,6 @@ function updateRegistry() {
 function isUpdateNotificationDisabled() {
   return process.env.CI !== void 0 || process.env.NO_UPDATE_NOTIFIER !== void 0 || process.env.THREADNOTE_NO_UPDATE_CHECK !== void 0;
 }
-function compareVersions2(currentVersion, latestVersion) {
-  const current = parseVersion2(currentVersion);
-  const latest = parseVersion2(latestVersion);
-  for (let index = 0; index < 3; index += 1) {
-    const difference = current.numbers[index] - latest.numbers[index];
-    if (difference !== 0) {
-      return difference;
-    }
-  }
-  if (current.prerelease === latest.prerelease) {
-    return 0;
-  }
-  if (current.prerelease === void 0) {
-    return 1;
-  }
-  if (latest.prerelease === void 0) {
-    return -1;
-  }
-  return current.prerelease.localeCompare(latest.prerelease);
-}
-function parseVersion2(version) {
-  const normalized = version.trim().replace(/^v/, "");
-  const [core2, prerelease] = normalized.split("-", 2);
-  const parts = core2.split(".").map((part) => Number(part));
-  return {
-    numbers: [safeVersionNumber(parts[0]), safeVersionNumber(parts[1]), safeVersionNumber(parts[2])],
-    prerelease
-  };
-}
-function safeVersionNumber(value) {
-  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : 0;
-}
 
 // src/lifecycle.ts
 async function runDoctor(config, options) {
@@ -10498,7 +10603,10 @@ async function runInstall(config, options) {
     console.log(`OpenViking server already installed: ${serverPath}`);
     const localEmbeddingMissing = await hasLocalEmbeddingDependency(serverPath) === false;
     const pythonSystemCertificatesMissing = await hasPythonSystemCertificatesPatch(serverPath) === false;
-    if (localEmbeddingMissing) {
+    if (options.force === true) {
+      console.log(`Reinstalling OpenViking at pinned version ${config.openVikingVersion} (--force).`);
+      await runInstallCommands(config, options.packageManager, true, dryRun);
+    } else if (localEmbeddingMissing) {
       const repairReasons = [];
       repairReasons.push("local embedding extra is missing");
       if (pythonSystemCertificatesMissing) {
@@ -11414,7 +11522,7 @@ async function main() {
     await runDoctor(config, options);
     await maybeNotifyUpdate(config, { dryRun: options.dryRun === true });
   });
-  program2.command("install").description("Install OpenViking, local config files, command shim, and user-level agent instructions").option("--dry-run", "Print the actions without making changes").option("--no-start", "Do not start OpenViking or check server health after installing").option("--package-manager <manager>", "uv, pipx, or pip", parsePackageManager).option(
+  program2.command("install").description("Install OpenViking, local config files, command shim, and user-level agent instructions").option("--dry-run", "Print the actions without making changes").option("--force", "Reinstall OpenViking at the pinned version even if a working install is already present").option("--no-start", "Do not start OpenViking or check server health after installing").option("--package-manager <manager>", "uv, pipx, or pip", parsePackageManager).option(
     "--with-hooks",
     "Also install agent-side hooks (Claude PreCompact + SessionStart) for deterministic handoff snapshots and context preload"
   ).action(async (options) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "threadnote",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "type": "commonjs",
   "main": "dist/threadnote.cjs",
   "description": "Shared local context and handoffs for development agents",