servyx-cli 0.1.6 → 0.1.8

package/README.md

@@ -13,23 +13,44 @@ 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
 cd my-app
 servyx link
 
-# 3. Deploy
+# 3. Deploy (server .env and .htaccess are preserved by default)
 servyx deploy
 
+# 3b. React/Vite frontends: upload local .env files too
+servyx deploy --with-env
+
 # 4. Check recent deployments
 servyx status
 ```
@@ -38,7 +59,7 @@ servyx status
 
 - Global config: `~/.servyx/config.json` (mode 600)
 - Project config: `servyx.json` in your project root
-- Optional excludes: `.servyxignore` (rsync patterns). Hidden files (`.env`, `.htaccess`, etc.) are not uploaded from your machine; existing server copies are preserved during deploy.
+- Optional excludes: `.servyxignore` (rsync patterns). By default, hidden files (`.env`, `.htaccess`, etc.) are not uploaded and existing server copies are preserved. Use `servyx deploy --with-env` to upload local `.env` / `.env.*` files (useful for React/Vite builds).
 
 Environment variables:
 
@@ -47,8 +68,8 @@ Environment variables:
 ## How it works
 
 1. `servyx deploy` fetches the deploy target (SSH user, host, staging path) from cli-service
-2. Files are rsynced to `<app_root>/.cli-staging` on the server (local hidden files are skipped)
-3. Live dotfiles from `public` (`.env`, `.htaccess`, etc.) are copied into staging so they are not removed on deploy
-4. cli-service calls server-service to queue a CLI deployment
-5. The agent syncs staging → public, runs the pipeline, and reports progress
-6. The CLI polls until the deployment succeeds or fails
+2. Files are rsynced to `<app_root>/.cli-staging` on the server (local hidden files are skipped unless `--with-env`)
+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 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.6",
+  "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';
@@ -58,12 +70,17 @@ export async function runDeploy(options = {}) {
     process.exit(1);
   }
 
+  const withEnv = Boolean(options.withEnv);
   const excludes = [
     ...DEFAULT_RSYNC_EXCLUDES,
     ...(target.rsync_excludes || []),
     ...loadServyxIgnore(root),
   ];
 
+  if (withEnv) {
+    console.log(pc.yellow('Including local .env files in this deploy.'));
+  }
+
   console.log(pc.bold('Syncing files via rsync...'));
   ensureRemoteDir({
     host: target.ssh_host,
@@ -84,6 +101,7 @@ export async function runDeploy(options = {}) {
     user: target.ssh_user,
     remotePath: target.staging_path,
     excludes,
+    withEnv,
   });
 
   const stagingCheck = verifyRemoteStagingDir({
@@ -103,20 +121,25 @@ export async function runDeploy(options = {}) {
   console.log(pc.green('Rsync complete.'));
 
   const publicPath = target.public_path || `${target.root_path}/public`;
-  console.log(pc.bold('Preserving server dotfiles (.env, .htaccess, etc.)...'));
+  if (!withEnv) {
+    console.log(pc.bold('Preserving server dotfiles (.env, .htaccess, etc.)...'));
+  } else {
+    console.log(pc.bold('Preserving server dotfiles (.htaccess, etc.)...'));
+  }
   preserveServerDotfiles({
     host: target.ssh_host,
     port: target.ssh_port || 22,
     user: target.ssh_user,
     publicPath,
     stagingPath: target.staging_path,
+    skipEnv: withEnv,
   });
   console.log(pc.green('Server dotfiles preserved.'));
 
   console.log(pc.bold('Starting deployment...'));
   let startResult;
   try {
-    startResult = await startDeployment(appId, message);
+    startResult = await startDeployment(appId, message, { withEnv });
   } catch (err) {
     if (err.code === 'APP_NOT_FOUND') {
       console.error(pc.red('Application not found by server-service.'));
@@ -138,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')
@@ -45,9 +46,10 @@ program
   .command('deploy')
   .description('Rsync local files and trigger a deployment')
   .option('-m, --message <message>', 'Deployment message')
+  .option('--with-env', 'Upload local .env files (for React/Vite frontends)')
   .action(async (options) => {
     try {
-      await runDeploy(options);
+      await runDeploy({ ...options, withEnv: Boolean(options.withEnv) });
     } catch (err) {
       console.error(pc.red(err.message || 'Deploy failed'));
       process.exit(1);

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;
 }
 
@@ -54,10 +61,13 @@ export async function getDeployTarget(appId) {
   return unwrap(await client.get(`/apps/${appId}/deploy-target`));
 }
 
-export async function startDeployment(appId, message) {
+export async function startDeployment(appId, message, { withEnv = false } = {}) {
   try {
     const client = createClient();
-    return unwrap(await client.post(`/apps/${appId}/deployments`, { message }));
+    return unwrap(await client.post(`/apps/${appId}/deployments`, {
+      message,
+      with_env: withEnv || undefined,
+    }));
   } catch (err) {
     mapNetworkError(err, 'start deployment');
   }

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/rsync.js

@@ -1,9 +1,34 @@
 import { spawnSync } from 'child_process';
 import path from 'path';
 
-/** Local hidden files are not uploaded; server copies are re-seeded into staging before deploy. */
+/** Local hidden files are not uploaded by default; server copies are re-seeded into staging before deploy. */
 export const DEFAULT_RSYNC_EXCLUDES = ['.*'];
 
+/** React/Vite-style env files that can be opted in with --with-env. */
+export const ENV_FILE_PATTERNS = ['.env', '.env.*'];
+
+export function buildRsyncFilters({ withEnv = false, excludes = [] } = {}) {
+  const filters = [];
+  if (withEnv) {
+    for (const pattern of ENV_FILE_PATTERNS) {
+      filters.push('--include', pattern);
+    }
+  }
+  filters.push('--exclude', '.*');
+
+  const filteredExcludes = excludes.filter((pattern) => {
+    if (pattern === '.*') return false;
+    if (withEnv && ENV_FILE_PATTERNS.includes(pattern)) return false;
+    return true;
+  });
+
+  for (const pattern of filteredExcludes) {
+    filters.push('--exclude', pattern);
+  }
+
+  return filters;
+}
+
 function shellQuote(value) {
   return `'${String(value).replace(/'/g, `'\\''`)}'`;
 }
@@ -36,7 +61,7 @@ export function sshPreflight({ host, port = 22, user }) {
   };
 }
 
-export function rsyncDeploy({ localDir, host, port = 22, user, remotePath, excludes = [] }) {
+export function rsyncDeploy({ localDir, host, port = 22, user, remotePath, excludes = [], withEnv = false }) {
   requireBinary('rsync');
   const target = `${user}@${host}:${remotePath.replace(/\/$/, '')}/`;
   const args = [
@@ -45,7 +70,7 @@ export function rsyncDeploy({ localDir, host, port = 22, user, remotePath, exclu
     '--human-readable',
     '--progress',
     '-e', `ssh -p ${port} -o StrictHostKeyChecking=accept-new`,
-    ...excludes.flatMap((pattern) => ['--exclude', pattern]),
+    ...buildRsyncFilters({ withEnv, excludes }),
     `${path.resolve(localDir)}/`,
     target,
   ];
@@ -107,14 +132,19 @@ export function verifyRemoteStagingDir({ host, port = 22, user, remotePath }) {
 }
 
 /** Copy live dotfiles from public into staging so the agent's staging→public sync does not delete them. */
-export function preserveServerDotfiles({ host, port = 22, user, publicPath, stagingPath }) {
+export function preserveServerDotfiles({ host, port = 22, user, publicPath, stagingPath, skipEnv = false }) {
   requireBinary('ssh');
   const target = `${user}@${host}`;
+  const skipEnvFlag = skipEnv ? '1' : '0';
   const cmd = [
     `mkdir -p ${shellQuote(stagingPath)}`,
-    `&& find ${shellQuote(publicPath)} -maxdepth 1 -name '.*' -type f`,
-    `-exec cp -a {} ${shellQuote(`${stagingPath.replace(/\/$/, '')}/`)} \\;`,
-    '2>/dev/null || true',
+    `&& SKIP_ENV=${skipEnvFlag}`,
+    `find ${shellQuote(publicPath)} -maxdepth 1 -name '.*' -type f`,
+    `| while IFS= read -r f; do`,
+    `base=$(basename "$f");`,
+    `if [ "$SKIP_ENV" = "1" ]; then case "$base" in .env|.env.*) continue;; esac; fi;`,
+    `cp -a "$f" ${shellQuote(`${stagingPath.replace(/\/$/, '')}/`)};`,
+    `done 2>/dev/null || true`,
   ].join(' ');
 
   const args = [

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;
+}