@onklave/agent-cli 0.1.42 → 0.1.43

package/main.js

@@ -735,8 +735,8 @@ var PlatformClient = class {
   /*
    * Make an authenticated HTTP request to the platform.
    */
-  async request(method, path8, body, extraHeaders) {
-    const url = `${this.baseUrl}${GATEWAY_SERVICE_PREFIX}${path8}`;
+  async request(method, path10, body, extraHeaders) {
+    const url = `${this.baseUrl}${GATEWAY_SERVICE_PREFIX}${path10}`;
     const headers = {
       Authorization: `Bearer ${this.token}`,
       "Content-Type": "application/json",
@@ -3009,7 +3009,7 @@ async function logsCommand(args) {
 }
 
 // _apps/@onklave/agent-cli/src/commands/daemon.command.ts
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 
 // _apps/@onklave/agent-cli/src/services/daemon-comms.service.ts
 var DaemonCommsService = class {
@@ -3436,8 +3436,8 @@ var PlatformBrokerClient = class {
       params
     );
   }
-  async request(method, path8, body) {
-    const url = `${this.baseUrl}/agent-orchestration${path8}`;
+  async request(method, path10, body) {
+    const url = `${this.baseUrl}/agent-orchestration${path10}`;
     const response = await fetch(url, {
       method,
       headers: {
@@ -3969,9 +3969,37 @@ function parseSemverNumeric(v) {
   ];
 }
 
+// _apps/@onklave/agent-cli/src/services/cli-version.ts
+import * as fs6 from "node:fs";
+import * as path7 from "node:path";
+import { fileURLToPath } from "node:url";
+function readPackageVersion() {
+  try {
+    const moduleDir = path7.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+      path7.join(moduleDir, "package.json"),
+      // bundled: dist root
+      path7.join(moduleDir, "..", "package.json"),
+      path7.join(moduleDir, "..", "..", "package.json"),
+      // dev: src/services -> root
+      path7.join(moduleDir, "..", "..", "..", "package.json")
+    ];
+    for (const p of candidates) {
+      if (!fs6.existsSync(p)) continue;
+      const pkg = JSON.parse(fs6.readFileSync(p, "utf8"));
+      if (pkg.name === PACKAGE_NAME && pkg.version) return pkg.version;
+    }
+  } catch {
+  }
+  return null;
+}
+function getCurrentVersion() {
+  return readPackageVersion() ?? "0.0.0";
+}
+
 // _apps/@onklave/agent-cli/src/services/daemon-state.service.ts
-import * as fs6 from "fs";
-import * as path7 from "path";
+import * as fs7 from "fs";
+import * as path8 from "path";
 import * as os6 from "os";
 var VALID_TRANSITIONS = {
   installing: ["registered"],
@@ -3983,10 +4011,10 @@ var VALID_TRANSITIONS = {
   stopped: ["starting"]
 };
 function defaultStateFilePath() {
-  return path7.join(os6.homedir(), ".config", "onklave", "daemon.state.json");
+  return path8.join(os6.homedir(), ".config", "onklave", "daemon.state.json");
 }
 function defaultPidFilePath() {
-  return path7.join(os6.homedir(), ".config", "onklave", "daemon.pid");
+  return path8.join(os6.homedir(), ".config", "onklave", "daemon.pid");
 }
 var DaemonStateError = class extends Error {
   constructor(message) {
@@ -4010,8 +4038,8 @@ var DaemonStateService = class {
    */
   static readPersisted(stateFile = defaultStateFilePath()) {
     try {
-      if (!fs6.existsSync(stateFile)) return null;
-      const raw = fs6.readFileSync(stateFile, "utf8");
+      if (!fs7.existsSync(stateFile)) return null;
+      const raw = fs7.readFileSync(stateFile, "utf8");
       const parsed = JSON.parse(raw);
       if (!parsed.state || !parsed.enteredAt) return null;
       return parsed;
@@ -4061,8 +4089,8 @@ var DaemonStateService = class {
     }
   }
   persist(reason) {
-    const dir = path7.dirname(this.stateFile);
-    fs6.mkdirSync(dir, { recursive: true });
+    const dir = path8.dirname(this.stateFile);
+    fs7.mkdirSync(dir, { recursive: true });
     const payload = {
       state: this.current,
       enteredAt: this.enteredAt.toISOString(),
@@ -4072,8 +4100,8 @@ var DaemonStateService = class {
       ...this.latestRuntime ? { runtime: this.latestRuntime } : {}
     };
     const tmp = `${this.stateFile}.tmp`;
-    fs6.writeFileSync(tmp, JSON.stringify(payload, null, 2));
-    fs6.renameSync(tmp, this.stateFile);
+    fs7.writeFileSync(tmp, JSON.stringify(payload, null, 2));
+    fs7.renameSync(tmp, this.stateFile);
   }
   /**
    * Publish the latest runtime snapshot. Persists to the state file
@@ -4091,7 +4119,7 @@ var DaemonStateService = class {
    */
   clearPersisted() {
     try {
-      fs6.unlinkSync(this.stateFile);
+      fs7.unlinkSync(this.stateFile);
     } catch {
     }
   }
@@ -4547,7 +4575,7 @@ function transitionToAction(next) {
 }
 function readPid(pidFile) {
   try {
-    const raw = fs7.readFileSync(pidFile, "utf8").trim();
+    const raw = fs8.readFileSync(pidFile, "utf8").trim();
     const parsed = Number.parseInt(raw, 10);
     return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
   } catch {
@@ -4556,12 +4584,12 @@ function readPid(pidFile) {
 }
 function writePid(pidFile) {
   const dir = pidFile.replace(/\/[^/]+$/, "");
-  fs7.mkdirSync(dir, { recursive: true });
-  fs7.writeFileSync(pidFile, String(process.pid), { mode: 384 });
+  fs8.mkdirSync(dir, { recursive: true });
+  fs8.writeFileSync(pidFile, String(process.pid), { mode: 384 });
 }
 function removePid(pidFile) {
   try {
-    fs7.unlinkSync(pidFile);
+    fs8.unlinkSync(pidFile);
   } catch {
   }
 }
@@ -4570,25 +4598,6 @@ function isPidAlive(pidFile) {
   if (pid == null) return false;
   return isProcessAlive(pid);
 }
-function readPackageVersion() {
-  try {
-    const candidates = [
-      // dist layout (bin/onklave.js → ../package.json)
-      `${__dirname}/../../package.json`,
-      // src layout during dev
-      `${__dirname}/../../../package.json`
-    ];
-    for (const p of candidates) {
-      if (fs7.existsSync(p)) {
-        const pkg = JSON.parse(fs7.readFileSync(p, "utf8"));
-        if (pkg.name === "@onklave/agent-cli" && pkg.version)
-          return pkg.version;
-      }
-    }
-  } catch {
-  }
-  return null;
-}
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -4623,8 +4632,157 @@ var COMMANDS = {
   daemon: daemonCommand
 };
 
+// _apps/@onklave/agent-cli/src/services/update-notifier.service.ts
+import * as fs9 from "node:fs";
+import * as path9 from "node:path";
+import * as os7 from "node:os";
+import { createInterface } from "node:readline/promises";
+import { spawnSync } from "node:child_process";
+var CHECK_TTL_MS = 24 * 60 * 60 * 1e3;
+var FETCH_DEADLINE_MS = 1500;
+var CACHE_PATH = path9.join(
+  os7.homedir(),
+  ".config",
+  "onklave",
+  "update-check.json"
+);
+function shouldPromptForUpdate(current, latest, dismissedVersion) {
+  if (!latest) return false;
+  if (!isNewerVersion(latest, current)) return false;
+  if (dismissedVersion && dismissedVersion === latest) return false;
+  return true;
+}
+async function maybeNotifyUpdate(deps = {}) {
+  const log = deps.log ?? ((m) => console.error(m));
+  try {
+    const isInteractive = deps.isInteractive ?? defaultIsInteractive;
+    if (!isInteractive()) return;
+    const now = deps.now ?? Date.now;
+    const read = deps.readCache ?? readCache;
+    const write = deps.writeCache ?? writeCache;
+    const current = deps.currentVersion ?? "0.0.0";
+    let cache = read();
+    if (!isCacheFresh(cache, now())) {
+      const fetchLatest = deps.fetchLatest ?? (() => defaultRegistryFetcher(PACKAGE_NAME));
+      try {
+        const latestVersion = await withTimeout(
+          fetchLatest(),
+          FETCH_DEADLINE_MS
+        );
+        cache = {
+          ...cache,
+          latestVersion,
+          lastCheckedAt: new Date(now()).toISOString()
+        };
+        write(cache);
+      } catch {
+        write({ ...cache, lastCheckedAt: new Date(now()).toISOString() });
+        return;
+      }
+    }
+    if (!shouldPromptForUpdate(
+      current,
+      cache.latestVersion,
+      cache.dismissedVersion
+    )) {
+      return;
+    }
+    const latest = cache.latestVersion;
+    log(
+      `
+\u2B06  A new version of the Onklave CLI is available: ${current} \u2192 ${latest}`
+    );
+    const promptYesNo = deps.promptYesNo ?? defaultPromptYesNo;
+    const accepted = await promptYesNo(
+      `   Update now (npm i -g ${PACKAGE_NAME}@latest)? [y/N] `
+    );
+    if (!accepted) {
+      write({ ...cache, dismissedVersion: latest });
+      log(
+        `   Skipped. Run \`npm i -g ${PACKAGE_NAME}@latest\` whenever you're ready.`
+      );
+      return;
+    }
+    const runUpdate = deps.runUpdate ?? defaultRunUpdate;
+    const ok = runUpdate();
+    if (ok) {
+      write({ ...cache, dismissedVersion: latest });
+      log(
+        `
+\u2705 Updated to ${latest}. Re-run your command to use the new version.`
+      );
+      (deps.exit ?? ((code) => process.exit(code)))(0);
+      return;
+    }
+    log(`
+\u26A0  Update failed. Try manually: npm i -g ${PACKAGE_NAME}@latest`);
+  } catch {
+  }
+}
+function withTimeout(promise, ms) {
+  return new Promise((resolve3, reject) => {
+    const timer = setTimeout(
+      () => reject(new Error("update check timed out")),
+      ms
+    );
+    if (typeof timer.unref === "function") timer.unref();
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve3(value);
+      },
+      (err) => {
+        clearTimeout(timer);
+        reject(err);
+      }
+    );
+  });
+}
+function defaultIsInteractive() {
+  if (process.env.NO_UPDATE_NOTIFIER) return false;
+  if (process.env.CI) return false;
+  return Boolean(process.stdout.isTTY && process.stdin.isTTY);
+}
+function isCacheFresh(cache, nowMs) {
+  if (!cache.lastCheckedAt) return false;
+  const last = new Date(cache.lastCheckedAt).getTime();
+  if (Number.isNaN(last)) return false;
+  return nowMs - last < CHECK_TTL_MS;
+}
+function readCache() {
+  try {
+    if (!fs9.existsSync(CACHE_PATH)) return {};
+    return JSON.parse(fs9.readFileSync(CACHE_PATH, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeCache(cache) {
+  try {
+    fs9.mkdirSync(path9.dirname(CACHE_PATH), { recursive: true, mode: 448 });
+    fs9.writeFileSync(CACHE_PATH, JSON.stringify(cache, null, 2), "utf8");
+  } catch {
+  }
+}
+async function defaultPromptYesNo(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const answer = (await rl.question(question)).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+function defaultRunUpdate() {
+  const result = spawnSync("npm", ["install", "-g", `${PACKAGE_NAME}@latest`], {
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+  return result.status === 0;
+}
+
 // _apps/@onklave/agent-cli/src/main.ts
-var VERSION = "0.1.0";
+var VERSION = getCurrentVersion();
 function showHelp() {
   console.log(
     `
@@ -4681,6 +4839,7 @@ async function main() {
     process.exitCode = 1;
     return;
   }
+  await maybeNotifyUpdate({ currentVersion: VERSION });
   const commandArgs = args.slice(1);
   if (commandArgs.includes("--help") || commandArgs.includes("-h")) {
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onklave/agent-cli",
-  "version": "0.1.42",
+  "version": "0.1.43",
   "description": "Onklave Agent CLI — local agent runner with cloud orchestration",
   "bin": {
     "onklave": "./main.js"