@onklave/agent-cli 0.1.41 → 0.1.43

package/main.js

@@ -127,6 +127,7 @@ var CredentialStore = class {
 
 // _apps/@onklave/agent-cli/src/services/auth.service.ts
 var DEFAULT_PLATFORM_URL = "https://api.onklave.app";
+var DEFAULT_COMMS_URL = "wss://comms.onklave.app";
 var AuthService = class {
   constructor() {
     this.store = new CredentialStore();
@@ -147,6 +148,7 @@ var AuthService = class {
       ...existing,
       token,
       platformUrl: metadata?.platformUrl ?? existing?.platformUrl ?? DEFAULT_PLATFORM_URL,
+      commsUrl: metadata?.commsUrl ?? existing?.commsUrl,
       userId: metadata?.userId ?? existing?.userId,
       orgId: metadata?.orgId ?? existing?.orgId,
       expiresAt: metadata?.expiresAt ?? existing?.expiresAt
@@ -206,6 +208,15 @@ var AuthService = class {
     const creds = await this.getCredentials();
     return creds?.platformUrl ?? DEFAULT_PLATFORM_URL;
   }
+  /*
+   * Get the comms (Socket.IO) URL from credentials or fallback to default.
+   * Resolved separately from the platform URL because comms is reached on a
+   * dedicated host, not through the gateway.
+   */
+  async getCommsUrl() {
+    const creds = await this.getCredentials();
+    return creds?.commsUrl ?? DEFAULT_COMMS_URL;
+  }
 };
 
 // _apps/@onklave/agent-cli/src/utils.ts
@@ -257,10 +268,11 @@ async function loginCommand(args) {
   const authService = new AuthService();
   const token = flags["token"];
   const platformUrl = flags["platform-url"];
+  const commsUrl = flags["comms-url"];
   if (typeof token !== "string" || !token) {
     console.log("Onklave Agent CLI \u2014 Login\n");
     console.log(
-      "Usage: onklave login --token <token> [--platform-url <url>]\n"
+      "Usage: onklave login --token <token> [--platform-url <url>] [--comms-url <url>]\n"
     );
     console.log("To obtain a token:");
     console.log(
@@ -277,6 +289,9 @@ async function loginCommand(args) {
   if (typeof platformUrl === "string") {
     metadata.platformUrl = platformUrl;
   }
+  if (typeof commsUrl === "string") {
+    metadata.commsUrl = commsUrl;
+  }
   try {
     await authService.saveToken(token, metadata);
     console.log("Successfully authenticated with Onklave platform.");
@@ -284,6 +299,9 @@ async function loginCommand(args) {
     if (typeof platformUrl === "string") {
       console.log(`Platform URL: ${platformUrl}`);
     }
+    if (typeof commsUrl === "string") {
+      console.log(`Comms URL: ${commsUrl}`);
+    }
   } catch (err) {
     console.error(`Login failed: ${err.message}`);
     process.exitCode = 1;
@@ -319,6 +337,7 @@ async function whoamiCommand() {
   const isValid = await authService.isAuthenticated();
   console.log("Onklave Agent CLI \u2014 Identity\n");
   console.log(`  Platform URL:  ${creds.platformUrl}`);
+  console.log(`  Comms URL:     ${await authService.getCommsUrl()}`);
   console.log(`  User ID:       ${creds.userId ?? "(not set)"}`);
   console.log(`  Org ID:        ${creds.orgId ?? "(not set)"}`);
   console.log(`  Machine ID:    ${creds.machineId ?? "(not registered)"}`);
@@ -548,6 +567,7 @@ var ConfigResolver = class {
 };
 
 // _apps/@onklave/agent-cli/src/services/platform-client.ts
+var GATEWAY_SERVICE_PREFIX = "/agent-orchestration";
 var PlatformClient = class {
   constructor(baseUrl, token) {
     this.baseUrl = baseUrl;
@@ -715,8 +735,8 @@ var PlatformClient = class {
   /*
    * Make an authenticated HTTP request to the platform.
    */
-  async request(method, path8, body, extraHeaders) {
-    const url = `${this.baseUrl}${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",
@@ -765,13 +785,15 @@ var CommsClient = class {
   }
   /*
    * Connect to the Onklave comms service via Socket.IO.
+   * `commsUrl` is the comms service host (e.g. wss://comms.onklave.app) — NOT
+   * the gateway/platform URL; comms is reached on its own dedicated ingress.
    * Pass `machineId` so the server can route inbound runner events
    * (e.g. `assignment:claim-available`) to this specific runner.
    */
-  async connect(platformUrl, token, extra) {
+  async connect(commsUrl, token, extra) {
     return new Promise((resolve3, reject) => {
-      const commsUrl = platformUrl.replace(/\/+$/, "");
-      this.socket = io(`${commsUrl}/agent-cli`, {
+      const baseUrl = commsUrl.replace(/\/+$/, "");
+      this.socket = io(`${baseUrl}/agent-cli`, {
         auth: {
           token,
           machineId: extra?.machineId,
@@ -1387,7 +1409,7 @@ var HeartbeatService = class {
     };
     try {
       const response = await fetch(
-        `${this.opts.platformUrl}/api/v1/runner/heartbeat`,
+        `${this.opts.platformUrl}/agent-orchestration/api/v1/runner/heartbeat`,
         {
           method: "POST",
           headers: {
@@ -2037,7 +2059,7 @@ async function runCommand(args) {
   const auditStreamer = new AuditStreamer(commsClient);
   try {
     console.log("Connecting to Onklave comms service...");
-    await commsClient.connect(resolvedConfig.platformUrl, creds.token, {
+    await commsClient.connect(await authService.getCommsUrl(), creds.token, {
       machineId: creds.machineId,
       deviceToken: creds.deviceToken,
       orgId: creds.orgId
@@ -2695,7 +2717,7 @@ async function checkWebSocket() {
   }
   const commsClient = new CommsClient();
   try {
-    await commsClient.connect(creds.platformUrl, creds.token);
+    await commsClient.connect(await authService.getCommsUrl(), creds.token);
     commsClient.disconnect();
     return {
       name: "WebSocket",
@@ -2987,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 {
@@ -3011,7 +3033,7 @@ var DaemonCommsService = class {
     let attempt = 0;
     while (!this.stopRequested) {
       try {
-        await this.client.connect(this.opts.platformUrl, this.opts.token, {
+        await this.client.connect(this.opts.commsUrl, this.opts.token, {
           machineId: this.opts.machineId,
           deviceToken: this.opts.deviceToken,
           orgId: this.opts.orgId
@@ -3414,8 +3436,8 @@ var PlatformBrokerClient = class {
       params
     );
   }
-  async request(method, path8, body) {
-    const url = `${this.baseUrl}${path8}`;
+  async request(method, path10, body) {
+    const url = `${this.baseUrl}/agent-orchestration${path10}`;
     const response = await fetch(url, {
       method,
       headers: {
@@ -3947,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"],
@@ -3961,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) {
@@ -3988,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;
@@ -4039,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(),
@@ -4050,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
@@ -4069,7 +4119,7 @@ var DaemonStateService = class {
    */
   clearPersisted() {
     try {
-      fs6.unlinkSync(this.stateFile);
+      fs7.unlinkSync(this.stateFile);
     } catch {
     }
   }
@@ -4232,8 +4282,9 @@ async function daemonStart() {
     creds.machineId
   );
   const platformUrl = await authService.getPlatformUrl();
+  const commsUrl = await authService.getCommsUrl();
   const comms = new DaemonCommsService({
-    platformUrl,
+    commsUrl,
     token: creds.token,
     machineId: creds.machineId,
     deviceToken: creds.deviceToken,
@@ -4524,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 {
@@ -4533,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 {
   }
 }
@@ -4547,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);
@@ -4600,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(
     `
@@ -4658,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.41",
+  "version": "0.1.43",
   "description": "Onklave Agent CLI — local agent runner with cloud orchestration",
   "bin": {
     "onklave": "./main.js"