threadnote 0.7.3 → 0.7.5

package/config/launchd/io.threadnote.openviking.plist.template

@@ -6,7 +6,7 @@
   <string>io.threadnote.openviking</string>
   <key>ProgramArguments</key>
   <array>
-    <string>openviking-server</string>
+    <string>{{OPENVIKING_SERVER_PATH}}</string>
     <string>--config</string>
     <string>{{THREADNOTE_HOME}}/ov.conf</string>
     <string>--host</string>

package/dist/threadnote.cjs

@@ -3850,6 +3850,27 @@ async function exists(path) {
     return false;
   }
 }
+async function isExecutable(path) {
+  try {
+    await (0, import_promises.access)(path, import_node_fs.constants.X_OK);
+    return true;
+  } catch (_err) {
+    return false;
+  }
+}
+function suggestedShellRc(shellPath, currentPlatform) {
+  const shell = shellPath ?? "";
+  if (shell.endsWith("/zsh")) {
+    return "~/.zshrc";
+  }
+  if (shell.endsWith("/bash")) {
+    return currentPlatform === "darwin" ? "~/.bash_profile" : "~/.bashrc";
+  }
+  if (shell.endsWith("/fish")) {
+    return "~/.config/fish/config.fish";
+  }
+  return "your shell rc";
+}
 async function isFile(path) {
   try {
     return (await (0, import_promises.stat)(path)).isFile();
@@ -7258,8 +7279,12 @@ function openVikingServerArgs(config) {
 function withIdentity(config, args) {
   return [...args, "--account", config.account, "--user", config.user, "--agent-id", config.agentId];
 }
-function renderTemplate(template, config) {
-  return template.replaceAll("{{THREADNOTE_HOME}}", config.agentContextHome).replaceAll("{{OPENVIKING_ACCOUNT}}", config.account).replaceAll("{{OPENVIKING_AGENT_ID}}", config.agentId).replaceAll("{{OPENVIKING_HOST}}", config.host).replaceAll("{{OPENVIKING_PORT}}", String(config.port)).replaceAll("{{OPENVIKING_USER}}", config.user);
+function renderTemplate(template, config, extras = {}) {
+  let rendered = template.replaceAll("{{THREADNOTE_HOME}}", config.agentContextHome).replaceAll("{{OPENVIKING_ACCOUNT}}", config.account).replaceAll("{{OPENVIKING_AGENT_ID}}", config.agentId).replaceAll("{{OPENVIKING_HOST}}", config.host).replaceAll("{{OPENVIKING_PORT}}", String(config.port)).replaceAll("{{OPENVIKING_USER}}", config.user);
+  for (const [key, value] of Object.entries(extras)) {
+    rendered = rendered.replaceAll(`{{${key}}}`, () => value);
+  }
+  return rendered;
 }
 
 // src/share.ts
@@ -10124,11 +10149,7 @@ async function runPostUpdate(config, options) {
     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,
-    interactive,
-    yes: options.yes === true
-  });
+  await ensurePinnedOpenVikingInstalled(config, { dryRun: options.dryRun === true });
   await runApplicablePostUpdateMigrations(config, {
     dryRun: options.dryRun === true,
     fromVersion: options.fromVersion,
@@ -10141,7 +10162,7 @@ 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, interactive, yes: false });
+  await ensurePinnedOpenVikingInstalled(config, { dryRun: options.dryRun });
   const state = await readPostUpdateState(config);
   const migrations = await applicablePostUpdateMigrations(config, {
     fromVersion: "0.0.0",
@@ -10184,18 +10205,80 @@ async function ensurePinnedOpenVikingInstalled(config, options) {
     return;
   }
   console.log("");
-  console.log(`OpenViking ${installedVersion} is older than the pinned version ${pinned}.`);
-  console.log(
-    "Upgrading picks up upstream fixes for share-sync reliability (reindex lock acquisition, ov wait timeout)."
-  );
+  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;
-  const installArgs = ["install", "--force", "--no-start"];
-  const accepted = options.dryRun || options.yes || options.interactive && await confirmPostUpdateMigration(`Upgrade OpenViking to ${pinned} now? [Y/n] `, true);
-  if (!accepted) {
-    console.log(`Skipped. Run manually later: ${formatMigrationCommand(threadnoteCommand, installArgs)}`);
+  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;
   }
-  await maybeRun(options.dryRun, threadnoteCommand, installArgs);
+  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 });
@@ -10455,14 +10538,6 @@ async function runtimeThreadnoteBin(runtime) {
   }
   return (0, import_node_path10.join)(process.env.DENO_INSTALL ?? (0, import_node_path10.join)((0, import_node_os5.homedir)(), ".deno"), "bin", NPM_PACKAGE_NAME);
 }
-async function isExecutable(path) {
-  try {
-    await (0, import_promises9.access)(path, import_node_fs5.constants.X_OK);
-    return true;
-  } catch (_err) {
-    return false;
-  }
-}
 function updatePackageCommand(runtime, registry) {
   if (runtime === "npm") {
     return { executable: "npm", args: ["install", "--global", `${NPM_PACKAGE_NAME}@latest`, `--registry=${registry}`] };
@@ -10506,7 +10581,7 @@ async function runDoctor(config, options) {
   checks.push({ name: "platform", status: (0, import_node_os6.platform)() === "darwin" ? "ok" : "warn", detail: (0, import_node_os6.platform)() });
   checks.push(await commandCheck("node", ["--version"]));
   checks.push(await commandCheck("python3", ["--version"]));
-  checks.push(await commandCheck("openviking-server", ["--help"]));
+  checks.push(await openVikingServerCheck());
   checks.push(await firstCommandCheck("openviking cli", ["ov", "openviking"], ["--help"]));
   checks.push(await localEmbeddingCheck());
   checks.push(await pythonSystemCertificatesCheck());
@@ -10540,7 +10615,8 @@ async function runInstall(config, options) {
   await ensureDirectory((0, import_node_path11.join)(config.agentContextHome, "mcp"), dryRun);
   await installCommandShim(dryRun);
   await installUserAgentInstructions(dryRun);
-  const serverPath = await findExecutable([OPENVIKING_SERVER_COMMAND]);
+  const serverPath = await findOpenVikingServer();
+  let serverInstallRan = false;
   if (serverPath) {
     console.log(`OpenViking server already installed: ${serverPath}`);
     const localEmbeddingMissing = await hasLocalEmbeddingDependency(serverPath) === false;
@@ -10548,6 +10624,7 @@ async function runInstall(config, options) {
     if (options.force === true) {
       console.log(`Reinstalling OpenViking at pinned version ${config.openVikingVersion} (--force).`);
       await runInstallCommands(config, options.packageManager, true, dryRun);
+      serverInstallRan = true;
     } else if (localEmbeddingMissing) {
       const repairReasons = [];
       repairReasons.push("local embedding extra is missing");
@@ -10556,6 +10633,7 @@ async function runInstall(config, options) {
       }
       console.log(`OpenViking install needs repair: ${repairReasons.join("; ")}.`);
       await runInstallCommands(config, options.packageManager, true, dryRun);
+      serverInstallRan = true;
     } else if (pythonSystemCertificatesMissing) {
       console.log("OpenViking install needs repair: Python system certificate bridge is missing.");
       const installCommand = await getPythonSystemCertificatesInstallCommand(serverPath);
@@ -10563,6 +10641,11 @@ async function runInstall(config, options) {
     }
   } else {
     await runInstallCommands(config, options.packageManager, false, dryRun);
+    serverInstallRan = true;
+  }
+  const resolvedServerPath = serverInstallRan ? await findOpenVikingServer() : serverPath;
+  if (resolvedServerPath && !dryRun) {
+    await maybePrintOpenVikingPathHint(resolvedServerPath);
   }
   await writeTemplateIfMissing({
     config,
@@ -10699,6 +10782,64 @@ async function repairManifest(config, dryRun) {
   await (0, import_promises11.chmod)(config.manifestPath, 384);
   console.log(`Wrote replacement manifest: ${config.manifestPath}`);
 }
+async function findOpenVikingServer() {
+  const onPath = await findExecutable([OPENVIKING_SERVER_COMMAND]);
+  if (onPath) {
+    return onPath;
+  }
+  for (const candidateDir of await openVikingServerCandidateDirs()) {
+    const candidate = (0, import_node_path11.join)(candidateDir, OPENVIKING_SERVER_COMMAND);
+    if (await isExecutable(candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+var candidateDirsPromise;
+async function openVikingServerCandidateDirs() {
+  if (!candidateDirsPromise) {
+    candidateDirsPromise = computeOpenVikingServerCandidateDirs();
+  }
+  return candidateDirsPromise;
+}
+async function computeOpenVikingServerCandidateDirs() {
+  const dirs = [];
+  const uv = await findExecutable(["uv"]);
+  if (uv) {
+    const result = await runCommand(uv, ["tool", "dir", "--bin"], { allowFailure: true });
+    if (result.exitCode === 0) {
+      const dir = result.stdout.trim();
+      if (dir) {
+        dirs.push(dir);
+      }
+    }
+  }
+  if (process.env.UV_TOOL_BIN_DIR) {
+    dirs.push(process.env.UV_TOOL_BIN_DIR);
+  }
+  dirs.push(expandPath("~/.local/bin"));
+  return Array.from(new Set(dirs));
+}
+async function requireOpenVikingServer() {
+  const resolved = await findOpenVikingServer();
+  if (!resolved) {
+    throw new Error(
+      `${OPENVIKING_SERVER_COMMAND} was not found in PATH, uv tool bin dir, $UV_TOOL_BIN_DIR, or ~/.local/bin. Run \`threadnote install\` first.`
+    );
+  }
+  return resolved;
+}
+async function maybePrintOpenVikingPathHint(serverPath) {
+  const onPath = await findExecutable([OPENVIKING_SERVER_COMMAND]);
+  if (onPath) {
+    return;
+  }
+  const binDir = (0, import_node_path11.dirname)(serverPath);
+  const rcHint = suggestedShellRc(process.env.SHELL, (0, import_node_os6.platform)());
+  console.log(
+    `Note: ${serverPath} is installed but ${binDir} is not on this shell's PATH. Add \`export PATH="${binDir}:$PATH"\` to ${rcHint} so other tools can find openviking-server.`
+  );
+}
 async function repairServerHealth(config, dryRun) {
   const existingHealth = await readOpenVikingHealthIfAvailable(config, 800);
   if (existingHealth) {
@@ -10719,7 +10860,7 @@ async function runStart(config, options) {
     await installLaunchAgent(config, options.dryRun === true);
     return;
   }
-  const server = options.dryRun === true ? await findExecutable([OPENVIKING_SERVER_COMMAND]) ?? OPENVIKING_SERVER_COMMAND : await requiredExecutable(OPENVIKING_SERVER_COMMAND);
+  const server = options.dryRun === true ? await findOpenVikingServer() ?? OPENVIKING_SERVER_COMMAND : await requireOpenVikingServer();
   const args = openVikingServerArgs(config);
   if (options.dryRun === true) {
     console.log(formatShellCommand(server, args));
@@ -10813,6 +10954,21 @@ async function commandCheck(name, args) {
     detail: firstLine(result.stdout || result.stderr) || executable
   };
 }
+async function openVikingServerCheck() {
+  const name = OPENVIKING_SERVER_COMMAND;
+  const executable = await findOpenVikingServer();
+  if (!executable) {
+    return { name, status: "fail", detail: "missing; install will fetch it via uv or pipx" };
+  }
+  const result = await runCommand(executable, ["--help"], { allowFailure: true });
+  const onPath = await findExecutable([OPENVIKING_SERVER_COMMAND]);
+  const detail = onPath ? executable : `${executable} (found outside PATH; add ${(0, import_node_path11.dirname)(executable)} to PATH)`;
+  return {
+    name,
+    status: result.exitCode === 0 ? "ok" : "warn",
+    detail: result.exitCode === 0 ? detail : firstLine(result.stderr || result.stdout) || detail
+  };
+}
 async function commandPresenceCheck(name, args) {
   const executable = await findExecutable([name]);
   if (!executable) {
@@ -10841,7 +10997,7 @@ async function firstCommandCheck(name, commands, args) {
   return { name, status: "fail", detail: `none found: ${commands.join(", ")}` };
 }
 async function localEmbeddingCheck() {
-  const serverPath = await findExecutable([OPENVIKING_SERVER_COMMAND]);
+  const serverPath = await findOpenVikingServer();
   if (!serverPath) {
     return { name: "local embedding extra", status: "warn", detail: "openviking-server missing" };
   }
@@ -10860,7 +11016,7 @@ async function localEmbeddingCheck() {
   };
 }
 async function pythonSystemCertificatesCheck() {
-  const serverPath = await findExecutable([OPENVIKING_SERVER_COMMAND]);
+  const serverPath = await findOpenVikingServer();
   if (!serverPath) {
     return { name: "python system certs", status: "warn", detail: "openviking-server missing" };
   }
@@ -11041,6 +11197,7 @@ async function installUv() {
         console.log(result.stdout.trim());
       }
       if (await findExecutable(["uv"])) {
+        candidateDirsPromise = void 0;
         return true;
       }
     } else {
@@ -11057,6 +11214,7 @@ async function installUv() {
         console.log(result.stdout.trim());
       }
       if (await findExecutable(["uv"])) {
+        candidateDirsPromise = void 0;
         return true;
       }
       console.warn(
@@ -11361,10 +11519,20 @@ async function installLaunchAgent(config, dryRun) {
   if ((0, import_node_os6.platform)() !== "darwin") {
     throw new Error("launchd autostart is only supported on macOS.");
   }
+  const resolvedServer = await findOpenVikingServer();
+  if (!resolvedServer && !dryRun) {
+    throw new Error(
+      `Cannot install LaunchAgent: ${OPENVIKING_SERVER_COMMAND} was not found in PATH, uv tool bin dir, $UV_TOOL_BIN_DIR, or ~/.local/bin. Run \`threadnote install\` first.`
+    );
+  }
   const source = (0, import_node_path11.join)(toolRoot(), "config", "launchd", `${LAUNCHD_LABEL}.plist.template`);
   const destination = expandPath(`~/Library/LaunchAgents/${LAUNCHD_LABEL}.plist`);
-  const rendered = renderTemplate(await (0, import_promises11.readFile)(source, "utf8"), config);
+  const rendered = renderTemplate(await (0, import_promises11.readFile)(source, "utf8"), config, {
+    OPENVIKING_SERVER_PATH: resolvedServer ?? OPENVIKING_SERVER_COMMAND
+  });
   if (dryRun) {
+    const resolutionDetail = resolvedServer ?? `<not found; would use bare \`${OPENVIKING_SERVER_COMMAND}\`>`;
+    console.log(`Resolved openviking-server: ${resolutionDetail}`);
     console.log(`Would write ${destination}`);
     console.log(`Would run: launchctl unload ${destination}`);
     console.log(`Would run: launchctl load ${destination}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "threadnote",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "type": "commonjs",
   "main": "dist/threadnote.cjs",
   "description": "Shared local context and handoffs for development agents",
@@ -43,18 +43,21 @@
     "clean": "rm -rf dist",
     "dev": "tsx src/threadnote.ts",
     "dev:mcp-server": "tsx src/mcp_server.ts",
-    "lint": "eslint \"src/**/*.ts\"",
-    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" \"test/**/*.ts\" --fix",
     "prepare": "husky",
-    "precommit": "npm run lint && npm run prettier:check",
+    "precommit": "npm run lint && npm run prettier:check && npm run test",
     "prepack": "npm run build",
     "prettier:check": "prettier --check \"**/*.{ts,js,cjs,json,md,yaml,yml}\"",
     "prettier:write": "prettier --write \"**/*.{ts,js,cjs,json,md,yaml,yml}\"",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
     "threadnote": "npm run build --silent && node ./bin/threadnote.cjs",
     "doctor": "npm run build --silent && node ./bin/threadnote.cjs doctor",
     "mcp-server": "npm run build --silent && node ./bin/threadnote-mcp-server.cjs",
     "pack:dry-run": "npm pack --dry-run",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit && tsc -p test/tsconfig.json --noEmit"
   },
   "engines": {
     "node": ">=20"
@@ -64,6 +67,7 @@
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^25.6.0",
+    "@vitest/coverage-v8": "^4.1.7",
     "commander": "^14.0.3",
     "esbuild": "^0.27.7",
     "eslint": "^10.3.0",
@@ -74,6 +78,7 @@
     "tsx": "^4.21.0",
     "typescript": "^6.0.3",
     "typescript-eslint": "^8.59.2",
+    "vitest": "^4.1.7",
     "zod": "^4.4.3"
   }
 }