@nolto/cli 0.4.0 → 0.5.0

package/dist/index.js

@@ -3,7 +3,7 @@
 // src/index.ts
 import { createRequire as createRequire2 } from "module";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import path7 from "path";
+import path8 from "path";
 import { CommanderError } from "commander";
 
 // src/config.ts
@@ -503,11 +503,11 @@ function createHttpClient(opts) {
   const { baseUrl, version, token } = opts;
   const base = baseUrl.replace(/\/+$/, "");
   return {
-    async post(path8, body) {
-      if (!path8.startsWith("/api/")) {
-        throw new CliError(`HTTP client path must start with /api/, got: ${path8}`, 2);
+    async post(path9, body) {
+      if (!path9.startsWith("/api/")) {
+        throw new CliError(`HTTP client path must start with /api/, got: ${path9}`, 2);
       }
-      const url = `${base}${path8}`;
+      const url = `${base}${path9}`;
       const headers = {
         "Content-Type": "application/json",
         "User-Agent": `${CLI_USER_AGENT_NAME}/${version}`
@@ -709,10 +709,7 @@ async function injectClaude(opts) {
     nolto: {
       url: mcpUrl,
       headers: {
-        Authorization: `Bearer ${opts.token}`
-      },
-      env: {
-        NOLTO_MCP_TOKEN: opts.token
+        Authorization: "Bearer ${NOLTO_MCP_TOKEN}"
       }
     }
   };
@@ -721,7 +718,14 @@ async function injectClaude(opts) {
     mcpServers: updatedServers
   };
   await atomicWrite(configPath, JSON.stringify(newConfig, null, 2) + "\n", 384);
-  process.stdout.write(`Updated ${configPath} (claude project .mcp.json)
+  const tokensUrl = `${opts.baseUrl.replace(/\/+$/, "")}/settings/tokens`;
+  process.stdout.write(
+    `Updated ${configPath} (claude project .mcp.json) \u2014 uses the NOLTO_MCP_TOKEN env var; no token is stored in the file, so it is safe to commit.
+`
+  );
+  process.stdout.write("Set NOLTO_MCP_TOKEN in your environment before launching Claude Code, e.g.:\n");
+  process.stdout.write("  export NOLTO_MCP_TOKEN=<your token>\n");
+  process.stdout.write(`Your token is saved in your nolto config (from this login); or create one at ${tokensUrl}
 `);
 }
 async function injectCodex(opts) {
@@ -1998,10 +2002,10 @@ async function handleShow(deps, projectBindingPath, mode2) {
   }
 }
 async function handleUnlink(projectBindingPath, mode2) {
-  const { readFile: readFile5, writeFile: writeFile4, chmod } = await import("fs/promises");
+  const { readFile: readFile6, writeFile: writeFile5, chmod } = await import("fs/promises");
   let existing = {};
   try {
-    const raw = await readFile5(projectBindingPath, "utf8");
+    const raw = await readFile6(projectBindingPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
       throw new CliError(
@@ -2016,7 +2020,7 @@ async function handleUnlink(projectBindingPath, mode2) {
   }
   const { projectId: _removed, ...rest } = existing;
   void _removed;
-  await writeFile4(projectBindingPath, JSON.stringify(rest, null, 2) + "\n", { mode: 420 });
+  await writeFile5(projectBindingPath, JSON.stringify(rest, null, 2) + "\n", { mode: 420 });
   await chmod(projectBindingPath, 420);
   if (mode2 === "json") {
     printResult({ unlinked: true, projectBindingPath }, mode2);
@@ -2119,12 +2123,109 @@ function buildProgram(deps) {
   return program;
 }
 
+// src/update-notifier.ts
+import { readFile as readFile5, writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
+import https from "https";
+import path7 from "path";
+var PACKAGE = "@nolto/cli";
+var CACHE_FILE = "update-check.json";
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var REQUEST_TIMEOUT_MS = 2e3;
+function isNewerVersion(latest, current) {
+  const parts = (v) => v.split("-")[0].split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const a = parts(latest);
+  const b = parts(current);
+  for (let i = 0; i < 3; i++) {
+    const x = a[i] ?? 0;
+    const y = b[i] ?? 0;
+    if (x !== y) return x > y;
+  }
+  return false;
+}
+function formatUpdateNotice(latest, current) {
+  return `
+Update available: ${current} \u2192 ${latest}  \xB7  npm i -g @nolto/cli@latest
+`;
+}
+function isDisabled(env) {
+  return env["NO_UPDATE_NOTIFIER"] === "1" || env["NODE_ENV"] === "test" || Boolean(env["CI"]);
+}
+function fetchLatestFromRegistry() {
+  return new Promise((resolve) => {
+    const req = https.get(
+      `https://registry.npmjs.org/${PACKAGE}/latest`,
+      { timeout: REQUEST_TIMEOUT_MS, headers: { accept: "application/json" } },
+      (res) => {
+        if (res.statusCode !== 200) {
+          res.resume();
+          resolve(null);
+          return;
+        }
+        let data = "";
+        res.on("data", (chunk) => data += chunk);
+        res.on("end", () => {
+          try {
+            const v = JSON.parse(data).version;
+            resolve(typeof v === "string" ? v : null);
+          } catch {
+            resolve(null);
+          }
+        });
+      }
+    );
+    req.on("socket", (s) => s.unref());
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(null);
+    });
+    req.on("error", () => resolve(null));
+  });
+}
+async function refreshCache(cachePath, now, fetchLatest) {
+  const latest = await fetchLatest();
+  if (!latest) return;
+  await mkdir4(path7.dirname(cachePath), { recursive: true }).catch(() => void 0);
+  const payload = { checkedAt: now, latest };
+  await writeFile4(cachePath, JSON.stringify(payload), { mode: 384 }).catch(() => void 0);
+}
+async function checkForUpdate(opts) {
+  if (isDisabled(opts.env)) return null;
+  const cachePath = path7.join(opts.configDir, CACHE_FILE);
+  let cache = {};
+  try {
+    cache = JSON.parse(await readFile5(cachePath, "utf8"));
+  } catch {
+  }
+  if (typeof cache.checkedAt !== "number" || opts.now - cache.checkedAt > CACHE_TTL_MS) {
+    void refreshCache(cachePath, opts.now, opts.fetchLatest ?? fetchLatestFromRegistry).catch(
+      () => void 0
+    );
+  }
+  if (typeof cache.latest === "string" && isNewerVersion(cache.latest, opts.current)) {
+    return cache.latest;
+  }
+  return null;
+}
+async function notifyUpdate(opts) {
+  try {
+    if (opts.isJson || !process.stderr.isTTY) return;
+    const latest = await checkForUpdate({
+      current: opts.current,
+      configDir: getConfigDir(opts.env),
+      env: opts.env,
+      now: opts.now
+    });
+    if (latest) process.stderr.write(formatUpdateNotice(latest, opts.current));
+  } catch {
+  }
+}
+
 // src/index.ts
-var __dirname2 = path7.dirname(fileURLToPath2(import.meta.url));
+var __dirname2 = path8.dirname(fileURLToPath2(import.meta.url));
 var require2 = createRequire2(import.meta.url);
 function getVersion() {
   try {
-    const pkgPath = path7.resolve(__dirname2, "../package.json");
+    const pkgPath = path8.resolve(__dirname2, "../package.json");
     const pkg = require2(pkgPath);
     return pkg.version ?? "0.0.0";
   } catch {
@@ -2183,6 +2284,7 @@ async function main() {
   };
   const program = buildProgram({ caller, settings, output: { mode }, version, configPath, projectBindingPath });
   await program.parseAsync(process.argv);
+  await notifyUpdate({ current: version, env: process.env, isJson: mode === "json", now: Date.now() });
 }
 function extractFlag(argv, name) {
   const idx = argv.indexOf(name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nolto/cli",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "CLI for Nolto — register plans and update progress from your terminal.",
   "license": "MIT",
   "type": "module",