@joytreesite/joytree 1.0.0

package/commands/ssh.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const readline = require('readline');
+const { api }  = require('../lib/api');
+const ui       = require('../lib/ui');
+
+async function prompt(q) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(r => rl.question(q, a => { rl.close(); r(a.trim()); }));
+}
+
+async function list() {
+  const spin = ui.spinner('Fetching SSH keys');
+  try {
+    const data = await api.get('/api/ssh-keys/list');
+    spin.stop();
+    const keys = Array.isArray(data) ? data : (data.keys || data.sshKeys || []);
+    if (!keys.length) {
+      ui.info('No SSH keys. Generate one: joytree ssh generate');
+      return;
+    }
+    ui.header(`SSH Keys (${keys.length})`);
+    ui.divider();
+    keys.forEach(k => {
+      console.log(`  ${ui.c.bold}${k.name || k.label || k.id}${ui.c.reset}  ${ui.c.dim}${k.id}${ui.c.reset}`);
+      if (k.fingerprint) console.log(`     ${ui.c.dim}fingerprint: ${k.fingerprint}${ui.c.reset}`);
+      if (k.createdAt)   console.log(`     ${ui.c.dim}created: ${new Date(k.createdAt).toLocaleString()}${ui.c.reset}`);
+    });
+    console.log();
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function generate(opts) {
+  let name = opts.name;
+  if (!name) {
+    name = await prompt(`${ui.c.bold}Key name/label:${ui.c.reset} `);
+    if (!name) { ui.error('Name is required.'); process.exit(1); }
+  }
+  const spin = ui.spinner(`Generating SSH key "${name}"`);
+  try {
+    const data = await api.post('/api/ssh-keys/generate', { name });
+    spin.stop(`SSH key generated!`);
+    ui.label('Name',        data.name || name);
+    ui.label('ID',          data.id || data.keyId || '—');
+    if (data.publicKey) {
+      ui.label('Public Key', '');
+      console.log(`\n${ui.c.dim}${data.publicKey}${ui.c.reset}\n`);
+      ui.info('Add this public key to your GitHub/GitLab account.');
+    }
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function del(keyId, opts) {
+  if (!opts.yes) {
+    const ans = await prompt(`${ui.c.yellow}Delete SSH key "${keyId}"? Type yes to confirm: ${ui.c.reset}`);
+    if (ans.toLowerCase() !== 'yes') { ui.info('Cancelled.'); return; }
+  }
+  const spin = ui.spinner(`Deleting SSH key ${keyId}`);
+  try {
+    await api.delete(`/api/ssh-keys/${encodeURIComponent(keyId)}`);
+    spin.stop(`SSH key ${ui.c.bold}${keyId}${ui.c.reset} deleted.`);
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { list, generate, del };

package/commands/webhook.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const { api } = require('../lib/api');
+const ui      = require('../lib/ui');
+
+async function getSecret() {
+  const spin = ui.spinner('Fetching global webhook secret');
+  try {
+    const data = await api.get('/api/webhook/global-secret');
+    spin.stop();
+    ui.header('Global Webhook Secret');
+    ui.divider();
+    ui.label('Secret', data.secret || data.webhookSecret || '—');
+    if (data.webhookUrl) ui.label('Webhook URL', data.webhookUrl);
+    console.log(`\n  ${ui.c.dim}Use this secret to verify incoming webhook payloads from GitHub.${ui.c.reset}\n`);
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function rotateSecret() {
+  const spin = ui.spinner('Rotating webhook secret');
+  try {
+    const data = await api.post('/api/webhook/global-secret/regenerate', {});
+    spin.stop(`Webhook secret rotated!`);
+    ui.label('New Secret', data.secret || data.webhookSecret || '—');
+    ui.warn('Update this secret in your GitHub webhook settings.');
+    console.log();
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { getSecret, rotateSecret };

package/lib/api.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const https  = require('https');
+const http   = require('http');
+const { URL } = require('url');
+const config = require('./config');
+
+/**
+ * Make an authenticated request to the Joytree API.
+ * Auth is done via ?api_key=jtk_... (same pattern as /api/v1/transfer).
+ * For session-based endpoints we pass token as Bearer header.
+ */
+async function request(method, endpoint, body = null, opts = {}) {
+  const apiKey  = config.getApiKey();
+  const baseUrl = config.getBaseUrl();
+
+  if (!apiKey && !opts.noAuth) {
+    throw new Error('Not authenticated. Run: joytree login');
+  }
+
+  const separator = endpoint.includes('?') ? '&' : '?';
+  const url = new URL(`${baseUrl}${endpoint}${apiKey ? `${separator}api_key=${encodeURIComponent(apiKey)}` : ''}`);
+
+  const payload = body ? JSON.stringify(body) : null;
+
+  return new Promise((resolve, reject) => {
+    const mod = url.protocol === 'https:' ? https : http;
+    const reqOpts = {
+      hostname: url.hostname,
+      port: url.port || (url.protocol === 'https:' ? 443 : 80),
+      path: url.pathname + url.search,
+      method: method.toUpperCase(),
+      headers: {
+        'Content-Type': 'application/json',
+        'User-Agent': `joytree-cli/${require('../package.json').version}`,
+        ...(payload ? { 'Content-Length': Buffer.byteLength(payload) } : {}),
+        ...(opts.headers || {}),
+      },
+    };
+
+    const req = mod.request(reqOpts, (res) => {
+      let raw = '';
+      res.on('data', chunk => raw += chunk);
+      res.on('end', () => {
+        if (res.statusCode === 204) return resolve({ ok: true });
+        try {
+          const data = JSON.parse(raw);
+          if (res.statusCode >= 400) {
+            const msg = data.error || data.message || `HTTP ${res.statusCode}`;
+            reject(new Error(msg));
+          } else {
+            resolve(data);
+          }
+        } catch {
+          reject(new Error(`Non-JSON response (${res.statusCode}): ${raw.slice(0, 200)}`));
+        }
+      });
+    });
+
+    req.on('error', reject);
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+
+// Convenience wrappers
+const api = {
+  get:    (path, opts)       => request('GET',    path, null, opts),
+  post:   (path, body, opts) => request('POST',   path, body, opts),
+  put:    (path, body, opts) => request('PUT',    path, body, opts),
+  patch:  (path, body, opts) => request('PATCH',  path, body, opts),
+  delete: (path, opts)       => request('DELETE', path, null, opts),
+};
+
+/**
+ * Validate an API key by calling /api/v1/transfer and reading the response.
+ * Returns { ok, email, projectCount } or throws.
+ */
+async function validateApiKey(apiKey, baseUrl) {
+  const url = `${baseUrl}/api/v1/transfer?api_key=${encodeURIComponent(apiKey)}`;
+  const parsed = new URL(url);
+  const mod = parsed.protocol === 'https:' ? require('https') : require('http');
+
+  return new Promise((resolve, reject) => {
+    const req = mod.get(url, {
+      headers: { 'User-Agent': `joytree-cli/${require('../package.json').version}` }
+    }, (res) => {
+      let raw = '';
+      res.on('data', c => raw += c);
+      res.on('end', () => {
+        try {
+          const data = JSON.parse(raw);
+          if (res.statusCode >= 400) reject(new Error(data.error || `HTTP ${res.statusCode}`));
+          else resolve(data);
+        } catch {
+          reject(new Error('Invalid response from server'));
+        }
+      });
+    });
+    req.on('error', reject);
+  });
+}
+
+module.exports = { api, validateApiKey };

package/lib/config.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const CONFIG_DIR  = path.join(os.homedir(), '.joytree');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'credentials.json');
+
+function load() {
+  try {
+    if (!fs.existsSync(CONFIG_FILE)) return {};
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function save(data) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+
+function getApiKey() {
+  return load().apiKey || process.env.JOYTREE_API_KEY || null;
+}
+
+function getBaseUrl() {
+  return load().baseUrl
+    || process.env.JOYTREE_BASE_URL
+    || 'https://joytree.app';
+}
+
+function setCredentials({ apiKey, baseUrl, email }) {
+  const existing = load();
+  save({ ...existing, apiKey, baseUrl: baseUrl || existing.baseUrl || 'https://joytree.app', email });
+}
+
+function clearCredentials() {
+  save({});
+}
+
+module.exports = { load, save, getApiKey, getBaseUrl, setCredentials, clearCredentials, CONFIG_FILE };

package/lib/ui.js

@@ -0,0 +1,90 @@
+'use strict';
+
+// ANSI colours (auto-disabled if not a TTY)
+const isTTY = process.stdout.isTTY;
+
+const c = {
+  reset:  isTTY ? '\x1b[0m'  : '',
+  bold:   isTTY ? '\x1b[1m'  : '',
+  dim:    isTTY ? '\x1b[2m'  : '',
+  green:  isTTY ? '\x1b[32m' : '',
+  cyan:   isTTY ? '\x1b[36m' : '',
+  yellow: isTTY ? '\x1b[33m' : '',
+  red:    isTTY ? '\x1b[31m' : '',
+  blue:   isTTY ? '\x1b[34m' : '',
+  magenta:isTTY ? '\x1b[35m' : '',
+  white:  isTTY ? '\x1b[37m' : '',
+};
+
+function logo() {
+  const pkg = require('../package.json');
+  console.log('');
+  console.log(`${c.bold}${c.white}     ██╗ ██████╗ ██╗   ██╗████████╗██████╗ ███████╗███████╗${c.reset}`);
+  console.log(`${c.bold}${c.white}     ██║██╔═══██╗╚██╗ ██╔╝╚══██╔══╝██╔══██╗██╔════╝██╔════╝${c.reset}`);
+  console.log(`${c.bold}${c.white}     ██║██║   ██║ ╚████╔╝    ██║   ██████╔╝█████╗  █████╗  ${c.reset}`);
+  console.log(`${c.bold}${c.white}██   ██║██║   ██║  ╚██╔╝     ██║   ██╔══██╗██╔══╝  ██╔══╝  ${c.reset}`);
+  console.log(`${c.bold}${c.white}╚█████╔╝╚██████╔╝   ██║      ██║   ██║  ██║███████╗███████╗${c.reset}`);
+  console.log(`${c.bold}${c.white} ╚════╝  ╚═════╝    ╚═╝      ╚═╝   ╚═╝  ╚═╝╚══════╝╚══════╝${c.reset}`);
+  console.log('');
+  console.log(`  Go live on Joytree in seconds!  ${c.dim}v${pkg.version}${c.reset}`);
+  console.log(`  Website  ${c.cyan}https://joytree.app${c.reset}`);
+  console.log(`  Docs     ${c.cyan}https://docs.joytree.app${c.reset}`);
+  console.log('');
+}
+
+function success(msg) { console.log(`${c.green}✓${c.reset} ${msg}`); }
+function info(msg)    { console.log(`${c.cyan}ℹ${c.reset} ${msg}`); }
+function warn(msg)    { console.log(`${c.yellow}⚠${c.reset} ${msg}`); }
+function error(msg)   { console.error(`${c.red}✗${c.reset} ${c.red}${msg}${c.reset}`); }
+function label(k, v)  { console.log(`  ${c.bold}${k}${c.reset}${c.dim}:${c.reset} ${v}`); }
+function header(msg)  { console.log(`\n${c.bold}${c.cyan}${msg}${c.reset}`); }
+function divider()    { console.log(c.dim + '─'.repeat(52) + c.reset); }
+
+function table(rows) {
+  if (!rows.length) return;
+  // Find column widths
+  const keys = Object.keys(rows[0]);
+  const widths = keys.map(k => Math.max(k.length, ...rows.map(r => String(r[k] ?? '').length)));
+  const pad = (s, w) => String(s ?? '').padEnd(w);
+  const row = r => keys.map((k, i) => pad(r[k], widths[i])).join('  ');
+  const sep = widths.map(w => '─'.repeat(w)).join('  ');
+
+  console.log(c.bold + row(Object.fromEntries(keys.map(k => [k, k.toUpperCase()]))) + c.reset);
+  console.log(c.dim + sep + c.reset);
+  rows.forEach(r => console.log(row(r)));
+}
+
+function statusBadge(status) {
+  const map = {
+    success: `${c.green}● success${c.reset}`,
+    live:    `${c.green}● live${c.reset}`,
+    running: `${c.green}● running${c.reset}`,
+    failed:  `${c.red}● failed${c.reset}`,
+    error:   `${c.red}● error${c.reset}`,
+    stopped: `${c.yellow}● stopped${c.reset}`,
+    pending: `${c.yellow}● pending${c.reset}`,
+    building:`${c.blue}● building${c.reset}`,
+    deploying:`${c.blue}● deploying${c.reset}`,
+  };
+  return map[String(status).toLowerCase()] || `${c.dim}● ${status}${c.reset}`;
+}
+
+function spinner(msg) {
+  if (!isTTY) { process.stdout.write(msg + '...\n'); return { stop: () => {} }; }
+  const frames = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'];
+  let i = 0;
+  process.stdout.write('\x1b[?25l'); // hide cursor
+  const iv = setInterval(() => {
+    process.stdout.write(`\r${c.cyan}${frames[i++ % frames.length]}${c.reset} ${msg}`);
+  }, 80);
+  return {
+    stop(successMsg) {
+      clearInterval(iv);
+      process.stdout.write('\x1b[?25h'); // show cursor
+      process.stdout.write('\r\x1b[K'); // clear line
+      if (successMsg) success(successMsg);
+    }
+  };
+}
+
+module.exports = { c, logo, success, info, warn, error, label, header, divider, table, statusBadge, spinner };

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@joytreesite/joytree",
+  "version": "1.0.0",
+  "description": "Joytree CLI — deploy and manage your sites from the terminal",
+  "main": "bin/joytree.js",
+  "bin": {
+    "joytree": "bin/joytree.js"
+  },
+  "scripts": {
+    "start": "node bin/joytree.js"
+  },
+  "keywords": ["joytree", "deploy", "hosting", "cli"],
+  "license": "MIT",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "dependencies": {
+    "commander": "^12.1.0"
+  }
+}