servyx-cli 0.1.0

package/README.md

@@ -0,0 +1,53 @@
+# servyx-cli
+
+Deploy local projects to Servyx by rsyncing files over SSH, then triggering the existing Servyx deployment queue and pipeline.
+
+## Prerequisites
+
+- Node.js 18+
+- `rsync` and `ssh` available on your PATH
+- Your SSH public key added to the app's system user in the Servyx dashboard
+- Network access to the target server on port 22
+
+## Install
+
+```bash
+npm install -g servyx-cli
+# or from source:
+cd servyx-cli && npm install && npm link
+```
+
+## Quick start
+
+```bash
+# 1. Authenticate (defaults to http://127.0.0.1:3871)
+servyx login
+
+# 2. Link your project directory to an app
+cd my-app
+servyx link
+
+# 3. Deploy
+servyx deploy
+
+# 4. Check recent deployments
+servyx status
+```
+
+## Configuration
+
+- Global config: `~/.servyx/config.json` (mode 600)
+- Project config: `servyx.json` in your project root
+- Optional excludes: `.servyxignore` (rsync patterns)
+
+Environment variables:
+
+- `SERVYX_API_URL` — override CLI service base URL
+
+## 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
+3. cli-service calls server-service to queue a CLI deployment
+4. The agent syncs staging → public, runs the pipeline, and reports progress
+5. The CLI polls until the deployment succeeds or fails

package/bin/servyx.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../src/index.js';

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "servyx-cli",
+  "version": "0.1.0",
+  "description": "Servyx CLI — rsync local projects and deploy via the Servyx platform",
+  "type": "module",
+  "bin": {
+    "servyx": "./bin/servyx.js"
+  },
+  "main": "src/index.js",
+  "files": [
+    "bin",
+    "src"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "start": "node bin/servyx.js"
+  },
+  "keywords": [
+    "servyx",
+    "deploy",
+    "rsync",
+    "cli"
+  ],
+  "author": "Servyx Team",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.7.9",
+    "commander": "^12.1.0",
+    "picocolors": "^1.1.1",
+    "prompts": "^2.4.2"
+  }
+}

package/src/commands/deploy.js

@@ -0,0 +1,118 @@
+import pc from 'picocolors';
+import { getDeployTarget, getDeployment, startDeployment } from '../lib/api.js';
+import { getToken } from '../lib/config.js';
+import { loadProjectConfig, loadServyxIgnore } from '../lib/project.js';
+import { rsyncDeploy, sshPreflight } from '../lib/rsync.js';
+
+const TERMINAL_STATUSES = new Set(['success', 'failure', 'cancelled']);
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function formatDeploymentLine(deployment) {
+  const pct = deployment.percent != null ? `${deployment.percent}%` : '';
+  const phase = deployment.phase || deployment.status || 'unknown';
+  const msg = deployment.message || '';
+  return `${pc.cyan(phase)} ${pct} ${msg}`.trim();
+}
+
+export async function runDeploy(options = {}) {
+  if (!getToken()) {
+    console.error(pc.red('Not logged in. Run: servyx login'));
+    process.exit(1);
+  }
+
+  const project = loadProjectConfig();
+  if (!project?.config?.appId) {
+    console.error(pc.red('No linked app. Run: servyx link'));
+    process.exit(1);
+  }
+
+  const { root, config } = project;
+  const appId = config.appId;
+  const message = options.message || `CLI deploy from ${config.appSlug || config.appName || 'local'}`;
+
+  console.log(pc.bold(`Deploying ${config.appName || config.appSlug}...`));
+
+  const targetResult = await getDeployTarget(appId);
+  const target = targetResult?.data;
+  if (!target?.ssh_host || !target?.ssh_user || !target?.staging_path) {
+    console.error(pc.red('Deploy target is incomplete. Check app configuration in the dashboard.'));
+    process.exit(1);
+  }
+
+  console.log(pc.dim(`SSH: ${target.ssh_user}@${target.ssh_host}:${target.ssh_port || 22}`));
+  console.log(pc.dim(`Staging: ${target.staging_path}`));
+
+  const sshCheck = sshPreflight({
+    host: target.ssh_host,
+    port: target.ssh_port || 22,
+    user: target.ssh_user,
+  });
+
+  if (!sshCheck.ok) {
+    console.error(pc.red('SSH connection failed.'));
+    console.error(pc.dim(sshCheck.stderr || 'Unable to connect with your SSH key.'));
+    console.error(pc.yellow('Add your SSH public key to the app system user in the Servyx dashboard, then retry.'));
+    process.exit(1);
+  }
+
+  const excludes = [
+    ...(target.rsync_excludes || []),
+    ...loadServyxIgnore(root),
+  ];
+
+  console.log(pc.bold('Syncing files via rsync...'));
+  rsyncDeploy({
+    localDir: root,
+    host: target.ssh_host,
+    port: target.ssh_port || 22,
+    user: target.ssh_user,
+    remotePath: target.staging_path,
+    excludes,
+  });
+  console.log(pc.green('Rsync complete.'));
+
+  console.log(pc.bold('Starting deployment...'));
+  const startResult = await startDeployment(appId, message);
+  const deployment = startResult?.data?.deployment;
+  const deploymentId = deployment?.id;
+
+  if (!deploymentId) {
+    console.error(pc.red('Failed to start deployment.'));
+    process.exit(1);
+  }
+
+  if (startResult?.data?.queue_position > 1) {
+    console.log(pc.yellow(`Queued at position ${startResult.data.queue_position}`));
+  }
+
+  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);
+    }
+
+    console.log(formatDeploymentLine(current));
+
+    if (TERMINAL_STATUSES.has(current.status)) {
+      if (current.status === 'success') {
+        console.log(pc.green('Deployment succeeded.'));
+        process.exit(0);
+      }
+
+      console.error(pc.red(`Deployment ${current.status}.`));
+      if (current.error_message) {
+        console.error(pc.red(current.error_message));
+      }
+      process.exit(1);
+    }
+
+    await sleep(2000);
+  }
+}

package/src/commands/link.js

@@ -0,0 +1,54 @@
+import prompts from 'prompts';
+import pc from 'picocolors';
+import { listApps } from '../lib/api.js';
+import { getToken } from '../lib/config.js';
+import { loadProjectConfig, saveProjectConfig } from '../lib/project.js';
+
+export async function runLink(options = {}) {
+  if (!getToken()) {
+    console.error(pc.red('Not logged in. Run: servyx login'));
+    process.exit(1);
+  }
+
+  const result = await listApps();
+  const apps = result?.data?.apps || [];
+  if (!apps.length) {
+    console.error(pc.red('No apps found for your account.'));
+    process.exit(1);
+  }
+
+  let appId = options.app;
+  if (!appId) {
+    const answer = await prompts({
+      type: 'select',
+      name: 'appId',
+      message: 'Select an app to link',
+      choices: apps.map((app) => ({
+        title: `${app.name} (${app.slug}) — ${app.server_name || app.hostname}`,
+        value: app.id,
+      })),
+    });
+    if (!answer.appId) {
+      console.log(pc.yellow('Link cancelled.'));
+      process.exit(1);
+    }
+    appId = answer.appId;
+  }
+
+  const app = apps.find((a) => String(a.id) === String(appId));
+  if (!app) {
+    console.error(pc.red('App not found.'));
+    process.exit(1);
+  }
+
+  const cwd = process.cwd();
+  saveProjectConfig(cwd, {
+    appId: app.id,
+    appName: app.name,
+    appSlug: app.slug,
+    linkedAt: new Date().toISOString(),
+  });
+
+  console.log(pc.green(`Linked ${app.name} (${app.slug})`));
+  console.log(pc.dim(`Wrote servyx.json in ${cwd}`));
+}

package/src/commands/login.js

@@ -0,0 +1,67 @@
+import prompts from 'prompts';
+import pc from 'picocolors';
+import { login } from '../lib/api.js';
+import { getApiBaseUrl, setAuth } from '../lib/config.js';
+
+export async function runLogin(options = {}) {
+  const apiUrl = options.api || getApiBaseUrl();
+
+  let username = options.username;
+  let password = options.password;
+  let otp = options.otp;
+
+  if (!username) {
+    const answer = await prompts({
+      type: 'text',
+      name: 'username',
+      message: 'Email or username',
+      validate: (v) => v.trim() ? true : 'Required',
+    });
+    if (!answer.username) {
+      console.log(pc.yellow('Login cancelled.'));
+      process.exit(1);
+    }
+    username = answer.username;
+  }
+
+  if (!password) {
+    const answer = await prompts({
+      type: 'password',
+      name: 'password',
+      message: 'Password',
+      validate: (v) => v ? true : 'Required',
+    });
+    if (!answer.password) {
+      console.log(pc.yellow('Login cancelled.'));
+      process.exit(1);
+    }
+    password = answer.password;
+  }
+
+  let result = await login({ username, password, otp, apiUrl });
+
+  if (!otp && result?.data?.requires_2fa) {
+    const answer = await prompts({
+      type: 'text',
+      name: 'otp',
+      message: 'Two-factor code',
+      validate: (v) => v.trim() ? true : 'Required',
+    });
+    if (!answer.otp) {
+      console.log(pc.yellow('Login cancelled.'));
+      process.exit(1);
+    }
+    result = await login({ username, password, otp: answer.otp, apiUrl });
+  }
+
+  const token = result?.data?.token;
+  const user = result?.data?.user;
+  if (!token) {
+    console.error(pc.red('Login failed: no token received'));
+    process.exit(1);
+  }
+
+  setAuth({ token, apiUrl, user });
+  console.log(pc.green(`Logged in as ${user?.username || user?.email || username}`));
+  console.log(pc.dim(`API: ${apiUrl}`));
+}

package/src/commands/status.js

@@ -0,0 +1,34 @@
+import pc from 'picocolors';
+import { listAppDeployments } from '../lib/api.js';
+import { getToken } from '../lib/config.js';
+import { loadProjectConfig } from '../lib/project.js';
+
+export async function runStatus(options = {}) {
+  if (!getToken()) {
+    console.error(pc.red('Not logged in. Run: servyx login'));
+    process.exit(1);
+  }
+
+  const project = loadProjectConfig();
+  if (!project?.config?.appId) {
+    console.error(pc.red('No linked app. Run: servyx link'));
+    process.exit(1);
+  }
+
+  const limit = options.limit || 10;
+  const result = await listAppDeployments(project.config.appId, limit);
+  const deployments = result?.data?.deployments || [];
+
+  if (!deployments.length) {
+    console.log(pc.yellow('No deployments found.'));
+    return;
+  }
+
+  console.log(pc.bold(`Recent deployments for ${project.config.appName || project.config.appSlug}`));
+  for (const d of deployments) {
+    const when = d.finished_at || d.started_at || d.created_at;
+    const pct = d.percent != null ? `${d.percent}%` : '';
+    console.log(`${pc.cyan(d.status.padEnd(12))} ${pc.dim(d.id)} ${d.phase || ''} ${pct} ${d.message || ''}`.trim());
+    if (when) console.log(pc.dim(`  ${when}`));
+  }
+}

package/src/index.js

@@ -0,0 +1,70 @@
+import { Command } from 'commander';
+import pc from 'picocolors';
+import { runLogin } from './commands/login.js';
+import { runLink } from './commands/link.js';
+import { runDeploy } from './commands/deploy.js';
+import { runStatus } from './commands/status.js';
+
+const program = new Command();
+
+program
+  .name('servyx')
+  .description('Servyx CLI — rsync and deploy applications')
+  .version('0.1.0');
+
+program
+  .command('login')
+  .description('Authenticate with Servyx')
+  .option('--api <url>', 'CLI service API URL')
+  .option('-u, --username <username>', 'Email or username')
+  .option('-p, --password <password>', 'Password')
+  .option('--otp <code>', 'Two-factor code')
+  .action(async (options) => {
+    try {
+      await runLogin(options);
+    } catch (err) {
+      console.error(pc.red(err.message || 'Login failed'));
+      process.exit(1);
+    }
+  });
+
+program
+  .command('link')
+  .description('Link the current directory to a Servyx app')
+  .option('--app <id>', 'App ID to link')
+  .action(async (options) => {
+    try {
+      await runLink(options);
+    } catch (err) {
+      console.error(pc.red(err.message || 'Link failed'));
+      process.exit(1);
+    }
+  });
+
+program
+  .command('deploy')
+  .description('Rsync local files and trigger a deployment')
+  .option('-m, --message <message>', 'Deployment message')
+  .action(async (options) => {
+    try {
+      await runDeploy(options);
+    } catch (err) {
+      console.error(pc.red(err.message || 'Deploy failed'));
+      process.exit(1);
+    }
+  });
+
+program
+  .command('status')
+  .description('Show recent deployments for the linked app')
+  .option('-n, --limit <count>', 'Number of deployments to show', '10')
+  .action(async (options) => {
+    try {
+      await runStatus({ ...options, limit: Number(options.limit) || 10 });
+    } catch (err) {
+      console.error(pc.red(err.message || 'Status failed'));
+      process.exit(1);
+    }
+  });
+
+program.parseAsync(process.argv);

package/src/lib/api.js

@@ -0,0 +1,58 @@
+import axios from 'axios';
+import { getApiBaseUrl, getToken } from './config.js';
+
+function createClient(token = getToken()) {
+  const baseURL = `${getApiBaseUrl()}/api/v1/cli`;
+  return axios.create({
+    baseURL,
+    timeout: 60000,
+    headers: {
+      'Content-Type': 'application/json',
+      ...(token ? { Authorization: `Bearer ${token}` } : {}),
+    },
+    validateStatus: () => true,
+  });
+}
+
+function unwrap(response) {
+  if (response.status >= 200 && response.status < 300) {
+    return response.data;
+  }
+  const err = new Error(response.data?.error || response.statusText || 'Request failed');
+  err.status = response.status;
+  err.code = response.data?.code;
+  err.data = response.data;
+  throw err;
+}
+
+export async function login({ username, password, otp, apiUrl }) {
+  const baseURL = `${(apiUrl || getApiBaseUrl()).replace(/\/+$/, '')}/api/v1/cli`;
+  const client = axios.create({ baseURL, timeout: 60000, validateStatus: () => true });
+  const response = await client.post('/auth/login', { username, password, otp });
+  return unwrap(response);
+}
+
+export async function listApps() {
+  const client = createClient();
+  return unwrap(await client.get('/apps'));
+}
+
+export async function getDeployTarget(appId) {
+  const client = createClient();
+  return unwrap(await client.get(`/apps/${appId}/deploy-target`));
+}
+
+export async function startDeployment(appId, message) {
+  const client = createClient();
+  return unwrap(await client.post(`/apps/${appId}/deployments`, { message }));
+}
+
+export async function getDeployment(deploymentId) {
+  const client = createClient();
+  return unwrap(await client.get(`/deployments/${deploymentId}`));
+}
+
+export async function listAppDeployments(appId, limit = 10) {
+  const client = createClient();
+  return unwrap(await client.get(`/apps/${appId}/deployments`, { params: { limit } }));
+}

package/src/lib/config.js

@@ -0,0 +1,49 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+const CONFIG_DIR = path.join(os.homedir(), '.servyx');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+export function getConfigDir() {
+  return CONFIG_DIR;
+}
+
+export function loadGlobalConfig() {
+  try {
+    if (!fs.existsSync(CONFIG_FILE)) return null;
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function saveGlobalConfig(config) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
+}
+
+export function getApiBaseUrl() {
+  const env = process.env.SERVYX_API_URL;
+  if (env) return env.replace(/\/+$/, '');
+  const cfg = loadGlobalConfig();
+  return (cfg?.apiUrl || 'http://127.0.0.1:3871').replace(/\/+$/, '');
+}
+
+export function getToken() {
+  const cfg = loadGlobalConfig();
+  return cfg?.token || null;
+}
+
+export function setAuth({ token, apiUrl, user }) {
+  const existing = loadGlobalConfig() || {};
+  saveGlobalConfig({
+    ...existing,
+    token,
+    apiUrl: apiUrl || existing.apiUrl || getApiBaseUrl(),
+    user: user || existing.user || null,
+    updatedAt: new Date().toISOString(),
+  });
+}

package/src/lib/project.js

@@ -0,0 +1,36 @@
+import fs from 'fs';
+import path from 'path';
+
+export const PROJECT_FILE = 'servyx.json';
+
+export function findProjectRoot(startDir = process.cwd()) {
+  let dir = path.resolve(startDir);
+  while (true) {
+    const candidate = path.join(dir, PROJECT_FILE);
+    if (fs.existsSync(candidate)) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+export function loadProjectConfig(cwd = process.cwd()) {
+  const root = findProjectRoot(cwd);
+  if (!root) return null;
+  const file = path.join(root, PROJECT_FILE);
+  return { root, config: JSON.parse(fs.readFileSync(file, 'utf8')) };
+}
+
+export function saveProjectConfig(root, config) {
+  const file = path.join(root, PROJECT_FILE);
+  fs.writeFileSync(file, JSON.stringify(config, null, 2) + '\n');
+}
+
+export function loadServyxIgnore(root) {
+  const file = path.join(root, '.servyxignore');
+  if (!fs.existsSync(file)) return [];
+  return fs.readFileSync(file, 'utf8')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line && !line.startsWith('#'));
+}

package/src/lib/rsync.js

@@ -0,0 +1,58 @@
+import { spawnSync } from 'child_process';
+import path from 'path';
+
+export function requireBinary(name) {
+  const result = spawnSync('which', [name], { encoding: 'utf8' });
+  if (result.status !== 0) {
+    throw new Error(`${name} is required but was not found in PATH`);
+  }
+  return result.stdout.trim();
+}
+
+export function sshPreflight({ host, port = 22, user }) {
+  requireBinary('ssh');
+  const target = `${user}@${host}`;
+  const args = [
+    '-o', 'BatchMode=yes',
+    '-o', 'StrictHostKeyChecking=accept-new',
+    '-o', `ConnectTimeout=10`,
+    '-p', String(port),
+    target,
+    'true',
+  ];
+  const result = spawnSync('ssh', args, { encoding: 'utf8' });
+  return {
+    ok: result.status === 0,
+    target,
+    stderr: (result.stderr || '').trim(),
+    stdout: (result.stdout || '').trim(),
+  };
+}
+
+export function rsyncDeploy({ localDir, host, port = 22, user, remotePath, excludes = [] }) {
+  requireBinary('rsync');
+  const target = `${user}@${host}:${remotePath.replace(/\/$/, '')}/`;
+  const args = [
+    '-az',
+    '--delete',
+    '--human-readable',
+    '--progress',
+    '-e', `ssh -p ${port} -o StrictHostKeyChecking=accept-new`,
+    ...excludes.flatMap((pattern) => ['--exclude', pattern]),
+    `${path.resolve(localDir)}/`,
+    target,
+  ];
+
+  const child = spawnSync('rsync', args, {
+    encoding: 'utf8',
+    stdio: 'inherit',
+  });
+
+  if (child.status !== 0) {
+    const err = new Error(`rsync failed with exit code ${child.status ?? 'unknown'}`);
+    err.exitCode = child.status;
+    throw err;
+  }
+
+  return { target };
+}