servyx-cli 0.1.7 → 0.1.8

package/README.md

@@ -13,14 +13,32 @@ Deploy local projects to Servyx by rsyncing files over SSH, then triggering the
 
 ```bash
 npm install -g servyx-cli
-# or from source:
+```
+
+This installs the `latest` published version (no version pin needed). To upgrade an existing install:
+
+```bash
+npm update -g servyx-cli
+# or explicitly:
+npm install -g servyx-cli@latest
+```
+
+Check your installed version:
+
+```bash
+servyx --version
+```
+
+From source:
+
+```bash
 cd servyx-cli && npm install && npm link
 ```
 
 ## Quick start
 
 ```bash
-# 1. Authenticate (defaults to https://cli.servyxhq.com)
+# 1. Authenticate
 servyx login
 
 # 2. Link your project directory to an app
@@ -54,4 +72,4 @@ Environment variables:
 3. Live dotfiles from `public` are copied into staging so they are not removed on deploy (`.env` is skipped when using `--with-env`)
 4. cli-service calls server-service to queue a CLI deployment (`with_env` tells the agent to sync uploaded env files)
 5. The agent syncs staging → public, preserving `.htaccess` and (by default) `.env` on the server
-6. The CLI polls until the deployment succeeds or fails
+6. The CLI listens on a live deploy stream (MQTT → cli-service SSE) until the deployment succeeds or fails, with slow HTTP fallback if streaming is unavailable

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "servyx-cli",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Servyx CLI — Upload local projects and deploy via the Servyx platform",
   "type": "module",
   "bin": {
@@ -15,7 +15,12 @@
     "node": ">=18.0.0"
   },
   "scripts": {
-    "start": "node bin/servyx.js"
+    "start": "node bin/servyx.js",
+    "prepublishOnly": "node -e \"const p=require('./package.json');const l=require('./package-lock.json');if(l.version!==p.version||l.packages[''].version!==p.version){console.error('package-lock.json version mismatch — run npm install');process.exit(1)}\""
+  },
+  "publishConfig": {
+    "tag": "latest",
+    "access": "public"
   },
   "keywords": [
     "servyx",

package/src/commands/deploy.js

@@ -1,15 +1,27 @@
 import pc from 'picocolors';
 import { getDeployTarget, getDeployment, startDeployment } from '../lib/api.js';
 import { getToken } from '../lib/config.js';
+import { watchDeploymentStream } from '../lib/deploy-stream.js';
 import { loadProjectConfig, loadServyxIgnore } from '../lib/project.js';
 import { rsyncDeploy, sshPreflight, DEFAULT_RSYNC_EXCLUDES, preserveServerDotfiles, ensureRemoteDir, verifyRemoteStagingDir } from '../lib/rsync.js';
 
 const TERMINAL_STATUSES = new Set(['success', 'failure', 'cancelled']);
+const FALLBACK_POLL_MS = 15000;
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function deploymentSnapshot(deployment) {
+  return [
+    deployment.status,
+    deployment.phase,
+    deployment.percent,
+    deployment.message,
+    deployment.error_message,
+  ].join('|');
+}
+
 function formatDeploymentLine(deployment) {
   const pct = deployment.percent != null ? `${deployment.percent}%` : '';
   const phase = deployment.phase || deployment.status || 'unknown';
@@ -149,29 +161,57 @@ export async function runDeploy(options = {}) {
 
   console.log(pc.dim(`Deployment ID: ${deploymentId}`));
 
-  while (true) {
-    const statusResult = await getDeployment(deploymentId);
-    const current = statusResult?.data?.deployment;
-    if (!current) {
-      console.error(pc.red('Deployment not found while polling.'));
-      process.exit(1);
-    }
+  let lastSnapshot = null;
+  let current = deployment;
 
-    console.log(formatDeploymentLine(current));
+  const handleDeploymentUpdate = (next) => {
+    current = next;
+    const snapshot = deploymentSnapshot(current);
+    if (snapshot !== lastSnapshot) {
+      console.log(formatDeploymentLine(current));
+      lastSnapshot = snapshot;
+    }
+  };
 
-    if (TERMINAL_STATUSES.has(current.status)) {
-      if (current.status === 'success') {
-        console.log(pc.green('Deployment succeeded.'));
-        process.exit(0);
-      }
+  try {
+    await watchDeploymentStream(deploymentId, {
+      onUpdate: (next) => handleDeploymentUpdate(next),
+    });
+  } catch (streamError) {
+    if (streamError.code !== 'MQTT_UNAVAILABLE' && streamError.status !== 404) {
+      console.log(pc.yellow(`Live deploy stream unavailable (${streamError.message}). Falling back to slow status checks...`));
+    } else if (streamError.code === 'MQTT_UNAVAILABLE') {
+      console.log(pc.yellow('MQTT deploy stream unavailable. Falling back to slow status checks...'));
+    } else {
+      throw streamError;
+    }
 
-      console.error(pc.red(`Deployment ${current.status}.`));
-      if (current.error_message) {
-        console.error(pc.red(current.error_message));
+    while (!TERMINAL_STATUSES.has(current?.status)) {
+      const statusResult = await getDeployment(deploymentId);
+      current = statusResult?.data?.deployment;
+      if (!current) {
+        console.error(pc.red('Deployment not found while checking status.'));
+        process.exit(1);
       }
-      process.exit(1);
+      handleDeploymentUpdate(current);
+      if (TERMINAL_STATUSES.has(current.status)) break;
+      await sleep(FALLBACK_POLL_MS);
     }
+  }
+
+  if (!current) {
+    console.error(pc.red('Deployment status unavailable.'));
+    process.exit(1);
+  }
+
+  if (current.status === 'success') {
+    console.log(pc.green('Deployment succeeded.'));
+    process.exit(0);
+  }
 
-    await sleep(2000);
+  console.error(pc.red(`Deployment ${current.status}.`));
+  if (current.error_message) {
+    console.error(pc.red(current.error_message));
   }
+  process.exit(1);
 }

package/src/index.js

@@ -4,13 +4,14 @@ import { runLogin } from './commands/login.js';
 import { runLink } from './commands/link.js';
 import { runDeploy } from './commands/deploy.js';
 import { runStatus } from './commands/status.js';
+import { getCliVersion } from './lib/version.js';
 
 const program = new Command();
 
 program
   .name('servyx')
   .description('Servyx CLI — rsync and deploy applications')
-  .version('0.1.0');
+  .version(getCliVersion());
 
 program
   .command('login')

package/src/lib/api.js

@@ -34,6 +34,13 @@ function unwrap(response) {
   err.status = response.status;
   err.code = response.data?.code;
   err.data = response.data;
+  const retryAfter = response.headers?.['retry-after'];
+  if (retryAfter) {
+    const seconds = Number.parseInt(retryAfter, 10);
+    if (!Number.isNaN(seconds)) {
+      err.retryAfterSeconds = seconds;
+    }
+  }
   throw err;
 }
 

package/src/lib/deploy-stream.js

@@ -0,0 +1,99 @@
+import { getApiBaseUrl, getToken } from './config.js';
+
+const TERMINAL_STATUSES = new Set(['success', 'failure', 'cancelled']);
+
+function parseSseChunk(buffer, onEvent) {
+  const blocks = buffer.split('\n\n');
+  const remainder = blocks.pop() || '';
+
+  for (const block of blocks) {
+    if (!block.trim()) continue;
+
+    let event = 'message';
+    let data = '';
+
+    for (const line of block.split('\n')) {
+      if (line.startsWith('event:')) {
+        event = line.slice(6).trim();
+      } else if (line.startsWith('data:')) {
+        data += line.slice(5).trim();
+      }
+    }
+
+    if (!data) continue;
+
+    try {
+      onEvent(event, JSON.parse(data));
+    } catch {
+      // Ignore malformed SSE frames
+    }
+  }
+
+  return remainder;
+}
+
+/**
+ * Watch deployment progress over a single long-lived SSE stream backed by MQTT.
+ */
+export async function watchDeploymentStream(deploymentId, { onUpdate, signal } = {}) {
+  const token = getToken();
+  if (!token) {
+    throw new Error('Not logged in');
+  }
+
+  const url = `${getApiBaseUrl()}/api/v1/cli/deployments/${deploymentId}/stream`;
+  const response = await fetch(url, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: 'text/event-stream',
+    },
+    signal,
+  });
+
+  if (!response.ok) {
+    const err = new Error(`Deploy stream failed (${response.status})`);
+    err.status = response.status;
+    throw err;
+  }
+
+  if (!response.body) {
+    throw new Error('Deploy stream response has no body');
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let latestDeployment = null;
+  let streamError = null;
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    buffer = parseSseChunk(buffer, (event, payload) => {
+      if (event === 'snapshot' || event === 'progress' || event === 'done') {
+        latestDeployment = payload?.deployment || latestDeployment;
+        if (latestDeployment) {
+          onUpdate?.(latestDeployment, { event, payload });
+        }
+      }
+
+      if (event === 'error') {
+        const err = new Error(payload?.message || 'Deploy stream error');
+        err.code = payload?.code;
+        streamError = err;
+      }
+    });
+
+    if (streamError) {
+      throw streamError;
+    }
+  }
+
+  return latestDeployment;
+}
+
+export function isTerminalDeployment(deployment) {
+  return TERMINAL_STATUSES.has(deployment?.status);
+}

package/src/lib/version.js

@@ -0,0 +1,9 @@
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const packagePath = join(dirname(fileURLToPath(import.meta.url)), '../../package.json');
+
+export function getCliVersion() {
+  return JSON.parse(readFileSync(packagePath, 'utf8')).version;
+}