easy-devops 0.2.6 → 0.2.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -13,11 +13,13 @@
13
13
  import chalk from 'chalk';
14
14
  import inquirer from 'inquirer';
15
15
  import ora from 'ora';
16
+ import fs from 'fs/promises';
16
17
  import Table from 'cli-table3';
17
18
  import { run } from '../../core/shell.js';
18
19
  import { loadConfig } from '../../core/config.js';
19
20
  import { getDomains, saveDomains, findDomain, createDomain, DOMAIN_DEFAULTS } from '../../dashboard/lib/domains-db.js';
20
21
  import { generateConf, buildConf } from '../../core/nginx-conf-generator.js';
22
+ import { issueCert } from './ssl-manager.js';
21
23
 
22
24
  const isWindows = process.platform === 'win32';
23
25
 
@@ -139,6 +141,66 @@ async function addDomainAction() {
139
141
  ssl = { ...ssl, ...sslDetails };
140
142
  }
141
143
 
144
+ // Cert existence check (FR-001, FR-002)
145
+ if (ssl.enabled) {
146
+ let certExists = false;
147
+ try {
148
+ await fs.access(ssl.certPath, fs.constants.F_OK);
149
+ certExists = true;
150
+ } catch {
151
+ certExists = false;
152
+ }
153
+
154
+ if (!certExists) {
155
+ console.log(chalk.yellow(`\n ⚠ Certificate not found at: ${ssl.certPath}`));
156
+
157
+ let certAction;
158
+ try {
159
+ ({ certAction } = await inquirer.prompt([{
160
+ type: 'list',
161
+ name: 'certAction',
162
+ message: 'What would you like to do?',
163
+ choices: ['Create certificate now', 'Disable SSL', 'Cancel'],
164
+ }]));
165
+ } catch (err) {
166
+ if (err.name === 'ExitPromptError') return;
167
+ throw err;
168
+ }
169
+
170
+ if (certAction === 'Cancel') {
171
+ console.log(chalk.gray('\n Cancelled.\n'));
172
+ return;
173
+ }
174
+
175
+ if (certAction === 'Disable SSL') {
176
+ ssl.enabled = false;
177
+ console.log(chalk.gray(' SSL disabled. Domain will be saved as HTTP-only.\n'));
178
+ }
179
+
180
+ if (certAction === 'Create certificate now') {
181
+ const spinner = ora(`Creating certificate for ${basic.name}…`).start();
182
+ const result = await issueCert(basic.name, { www: basic.www });
183
+ spinner.stop();
184
+
185
+ if (result.success) {
186
+ console.log(chalk.green('\n ✓ Certificate created successfully'));
187
+ console.log(chalk.gray(` Cert: ${result.certPath}`));
188
+ console.log(chalk.gray(` Key: ${result.keyPath}\n`));
189
+ ssl.certPath = result.certPath;
190
+ ssl.keyPath = result.keyPath;
191
+ } else {
192
+ const e = result.error;
193
+ console.log(chalk.red('\n ✗ Certificate creation failed — domain was not saved'));
194
+ console.log(chalk.yellow(` Step: ${e.step}`));
195
+ console.log(chalk.yellow(` Cause: ${e.cause}`));
196
+ console.log(chalk.yellow(` Consequence: ${e.consequence}`));
197
+ console.log(chalk.gray(` nginx running: ${e.nginxRunning ? 'yes' : 'no'}\n`));
198
+ return;
199
+ }
200
+ }
201
+ }
202
+ }
203
+
142
204
  // Section 3: Proxy Behavior
143
205
  const proxy = await inquirer.prompt([
144
206
  { type: 'input', name: 'maxBodySize', message: 'Max body size:', default: '10m' },
@@ -55,6 +55,18 @@ async function testConfig(nginxExe, nginxDir) {
55
55
  await ensureNginxInclude(nginxDir);
56
56
  const cmd = isWindows ? `& "${nginxExe}" -t` : 'nginx -t';
57
57
  const result = await run(cmd, { cwd: nginxDir });
58
+ const PathDomain = await import('fs/promises').then(fs => fs.exists(`${nginxDir}\\conf\\conf.d`));
59
+
60
+ if (!PathDomain) {
61
+ const createPath = await import('fs/promises').then(fs => fs.mkdir(`${nginxDir}\\conf\\conf.d`, { recursive: true }));
62
+ if (!createPath) {
63
+ return {
64
+ success: false,
65
+ output: `Failed to create conf.d directory at ${nginxDir}\\conf\\conf.d`,
66
+ };
67
+ }
68
+ }
69
+
58
70
  return {
59
71
  success: result.success,
60
72
  output: (result.stdout + '\n' + result.stderr).trim(),
@@ -239,32 +251,33 @@ async function installNginx() {
239
251
 
240
252
  // ── Windows ──────────────────────────────────────────────────────────────────
241
253
  const spinner = ora('Checking for winget…').start();
254
+ //! Winget is not reliably available on all Windows versions (missing from Windows Server, and some users report it missing on Windows 10 desktop), so we'll skip it for now and go straight to the direct download method. We can revisit this in the future if winget becomes more ubiquitous.
242
255
 
243
256
  // Try winget first (available on Windows 10/11 desktop; not on Windows Server by default)
244
- const wingetCheck = await run('where.exe winget 2>$null');
245
- const hasWinget = wingetCheck.success && wingetCheck.stdout.trim().length > 0;
246
-
247
- if (hasWinget) {
248
- spinner.text = 'Installing nginx via winget…';
249
- const result = await run(
250
- 'winget install -e --id Nginx.Nginx --accept-package-agreements --accept-source-agreements',
251
- { timeout: 120000 },
252
- );
253
- if (result.success) {
254
- spinner.succeed('nginx installed successfully');
255
- return { success: true, message: 'nginx installed successfully', output: result.stdout };
256
- }
257
- spinner.fail('winget install failed');
258
- console.log(chalk.red(result.stderr || result.stdout));
259
- console.log(chalk.gray('\n Manual instructions: https://nginx.org/en/docs/install.html\n'));
260
- return { success: false, message: 'Installation failed', output: result.stderr || result.stdout };
261
- }
257
+ // const wingetCheck = await run('where.exe winget 2>$null');
258
+ // const hasWinget = wingetCheck.success && wingetCheck.stdout.trim().length > 0;
259
+
260
+ // if (hasWinget) {
261
+ // spinner.text = 'Installing nginx via winget…';
262
+ // const result = await run(
263
+ // 'winget install -e --id Nginx.Nginx --accept-package-agreements --accept-source-agreements',
264
+ // { timeout: 120000 },
265
+ // );
266
+ // if (result.success) {
267
+ // spinner.succeed('nginx installed successfully');
268
+ // return { success: true, message: 'nginx installed successfully', output: result.stdout };
269
+ // }
270
+ // spinner.fail('winget install failed');
271
+ // console.log(chalk.red(result.stderr || result.stdout));
272
+ // console.log(chalk.gray('\n Manual instructions: https://nginx.org/en/docs/install.html\n'));
273
+ // return { success: false, message: 'Installation failed', output: result.stderr || result.stdout };
274
+ // }
262
275
 
263
276
  // ── Fallback: direct download from nginx.org ─────────────────────────────────
264
277
  spinner.text = 'Fetching latest nginx version…';
265
278
 
266
279
  // Try to resolve the current stable version; fall back to a known-good release
267
- const FALLBACK_VERSION = '1.26.3';
280
+ const FALLBACK_VERSION = '1.29.6';
268
281
  let nginxVersion = FALLBACK_VERSION;
269
282
 
270
283
  const fetchVersionResult = await run(
@@ -311,6 +324,9 @@ async function installNginx() {
311
324
  return { success: false, message: 'nginx.exe not found after extraction' };
312
325
  }
313
326
 
327
+ // Create conf/conf.d directory for domain config files
328
+ await import('fs/promises').then(fs => fs.mkdir(`${nginxDir}\\conf\\conf.d`, { recursive: true }));
329
+
314
330
  spinner.succeed(`nginx ${nginxVersion} installed to ${nginxDir}`);
315
331
  return { success: true, message: `nginx ${nginxVersion} installed successfully`, output: '' };
316
332
  }
@@ -680,6 +680,107 @@ async function installCertbot() {
680
680
  return { success: false };
681
681
  }
682
682
 
683
+ // ─── issueCert ────────────────────────────────────────────────────────────────
684
+
685
+ /**
686
+ * Issues a new SSL certificate using the installed ACME client.
687
+ * Stops nginx before the challenge and restarts it afterwards (always).
688
+ *
689
+ * @param {string} domainName - The primary domain name
690
+ * @param {{ www?: boolean }} options
691
+ * @returns {Promise<{ success: boolean, certPath: string|null, keyPath: string|null, error: object|null }>}
692
+ */
693
+ export async function issueCert(domainName, { www = false } = {}) {
694
+ // Guard: ACME client must be installed
695
+ const certbotExe = await getCertbotExe();
696
+ if (!certbotExe) {
697
+ return {
698
+ success: false,
699
+ certPath: null,
700
+ keyPath: null,
701
+ error: {
702
+ step: 'ACME client detection',
703
+ cause: 'No ACME client (certbot or win-acme) is installed on this server.',
704
+ consequence: 'No certificate was issued. Install certbot or win-acme using the SSL Manager first.',
705
+ nginxRunning: true,
706
+ configSaved: false,
707
+ },
708
+ };
709
+ }
710
+
711
+ const clientType = await getAcmeClientType();
712
+
713
+ // Stop nginx (tolerate failure — nginx may not have been running)
714
+ await stopNginx();
715
+
716
+ try {
717
+ // Check port 80 is free for the standalone challenge
718
+ const portCheck = await isPort80Busy();
719
+ if (portCheck.busy) {
720
+ await startNginx();
721
+ return {
722
+ success: false,
723
+ certPath: null,
724
+ keyPath: null,
725
+ error: {
726
+ step: 'port 80 check',
727
+ cause: `Port 80 is still in use: ${portCheck.detail}. Stop that process before creating a certificate.`,
728
+ consequence: 'The standalone ACME challenge cannot bind to port 80. No certificate was issued. nginx has been restarted.',
729
+ nginxRunning: true,
730
+ configSaved: false,
731
+ },
732
+ };
733
+ }
734
+
735
+ // Build and run the ACME command
736
+ const domainArgs = www ? `-d "${domainName}" -d "www.${domainName}"` : `-d "${domainName}"`;
737
+ const cmd = clientType === 'winacme'
738
+ ? certbotExe
739
+ : `${certbotExe} certonly --standalone --non-interactive --agree-tos ${domainArgs}`;
740
+
741
+ const exitCode = await runLive(cmd, { timeout: 120000 });
742
+
743
+ if (exitCode !== 0) {
744
+ await startNginx();
745
+ return {
746
+ success: false,
747
+ certPath: null,
748
+ keyPath: null,
749
+ error: {
750
+ step: 'ACME domain validation',
751
+ cause: 'The ACME challenge failed. Common causes: domain DNS does not point to this server, or port 80 is blocked by a firewall.',
752
+ consequence: 'No certificate was issued. nginx has been restarted.',
753
+ nginxRunning: true,
754
+ configSaved: false,
755
+ },
756
+ };
757
+ }
758
+
759
+ // Derive cert paths from the certbot live directory
760
+ const liveDir = getCertbotDir();
761
+ const certPath = path.join(liveDir, domainName, 'fullchain.pem');
762
+ const keyPath = path.join(liveDir, domainName, 'privkey.pem');
763
+
764
+ await startNginx();
765
+
766
+ return { success: true, certPath, keyPath, error: null };
767
+ } catch (err) {
768
+ try { await startNginx(); } catch { /* best effort */ }
769
+ return {
770
+ success: false,
771
+ certPath: null,
772
+ keyPath: null,
773
+ error: {
774
+ step: 'certificate issuance',
775
+ cause: err.message,
776
+ consequence: 'An unexpected error occurred during certificate issuance. nginx restart was attempted.',
777
+ nginxRunning: false,
778
+ configSaved: false,
779
+ },
780
+ };
781
+ }
782
+ }
783
+
683
784
  // ─── showSslManager ───────────────────────────────────────────────────────────
684
785
 
685
786
  export async function showSslManager() {
@@ -703,6 +804,7 @@ export async function showSslManager() {
703
804
  console.log();
704
805
 
705
806
  const choices = [
807
+ 'Create new certificate',
706
808
  'Renew a certificate',
707
809
  'Renew all expiring (< 30 days)',
708
810
  'Install certbot',
@@ -724,6 +826,51 @@ export async function showSslManager() {
724
826
  }
725
827
 
726
828
  switch (choice) {
829
+ case 'Create new certificate': {
830
+ const installed = await isCertbotInstalled();
831
+ if (!installed) {
832
+ console.log(chalk.yellow('\n ⚠ certbot/win-acme not found — select "Install certbot" first\n'));
833
+ break;
834
+ }
835
+
836
+ let domainInput, wwwInput;
837
+ try {
838
+ ({ domainInput } = await inquirer.prompt([{
839
+ type: 'input',
840
+ name: 'domainInput',
841
+ message: 'Domain name:',
842
+ validate: v => v.trim() ? true : 'Required',
843
+ }]));
844
+ ({ wwwInput } = await inquirer.prompt([{
845
+ type: 'confirm',
846
+ name: 'wwwInput',
847
+ message: 'Include www subdomain?',
848
+ default: false,
849
+ }]));
850
+ } catch (err) {
851
+ if (err.name === 'ExitPromptError') return;
852
+ throw err;
853
+ }
854
+
855
+ const spinner = ora(`Creating certificate for ${domainInput.trim()}…`).start();
856
+ const result = await issueCert(domainInput.trim(), { www: wwwInput });
857
+ spinner.stop();
858
+
859
+ if (result.success) {
860
+ console.log(chalk.green('\n ✓ Certificate created successfully'));
861
+ console.log(chalk.gray(` Cert: ${result.certPath}`));
862
+ console.log(chalk.gray(` Key: ${result.keyPath}\n`));
863
+ } else {
864
+ const e = result.error;
865
+ console.log(chalk.red('\n ✗ Certificate creation failed'));
866
+ console.log(chalk.yellow(` Step: ${e.step}`));
867
+ console.log(chalk.yellow(` Cause: ${e.cause}`));
868
+ console.log(chalk.yellow(` Consequence: ${e.consequence}`));
869
+ console.log(chalk.gray(` nginx running: ${e.nginxRunning ? 'yes' : 'no'}\n`));
870
+ }
871
+ break;
872
+ }
873
+
727
874
  case 'Renew a certificate': {
728
875
  const installed = await isCertbotInstalled();
729
876
  if (!installed) {
@@ -17,7 +17,7 @@ const isWindows = process.platform === 'win32';
17
17
  function getConfDDir(nginxDir) {
18
18
  return isWindows
19
19
  ? path.join(nginxDir, 'conf', 'conf.d')
20
- : path.join(nginxDir, 'conf.d');
20
+ : path.join(nginxDir, 'conf.d', 'conf.d');
21
21
  }
22
22
 
23
23
  /** Returns the path to nginx.conf. */
@@ -63,7 +63,12 @@ createApp({
63
63
  logs: [], logsLoading: false,
64
64
  },
65
65
 
66
- ssl: { certs: [], loading: false, error: '', renewingDomain: null },
66
+ ssl: {
67
+ certs: [], loading: false, error: '', renewingDomain: null,
68
+ showCreateForm: false,
69
+ createDomain: '', createWww: false,
70
+ creating: false, createResult: null, createError: null,
71
+ },
67
72
 
68
73
  // T017-T019: Updated domains state
69
74
  domains: {
@@ -73,6 +78,9 @@ createApp({
73
78
  saving: false,
74
79
  dirty: false, // T019: Track unsaved changes
75
80
  form: JSON.parse(JSON.stringify(DEFAULT_FORM)), // T025: Nested v2 structure
81
+ certMissing: null, // { certPath, keyPath, hint } set when POST /api/domains returns 422
82
+ certCreating: false, // true while POST /api/ssl/create is in-flight
83
+ certCreateError: null, // structured error from a failed cert creation
76
84
  },
77
85
 
78
86
  // T018: Collapsible section state
@@ -273,6 +281,30 @@ createApp({
273
281
  await this.loadSSL();
274
282
  },
275
283
 
284
+ async createCert() {
285
+ if (!this.ssl.createDomain.trim()) return;
286
+ this.ssl.creating = true;
287
+ this.ssl.createResult = null;
288
+ this.ssl.createError = null;
289
+ const r = await this.api('POST', '/api/ssl/create', {
290
+ domain: this.ssl.createDomain.trim(),
291
+ www: this.ssl.createWww,
292
+ });
293
+ this.ssl.creating = false;
294
+ if (r.ok) {
295
+ this.ssl.createResult = r.data;
296
+ this.ssl.createDomain = '';
297
+ this.ssl.createWww = false;
298
+ await this.loadSSL();
299
+ } else if (r.status === 503) {
300
+ this.ssl.createError = { step: 'ACME client detection', cause: r.data.hint, consequence: 'Install certbot or win-acme first using the SSL Manager CLI.', nginxRunning: true };
301
+ } else if (r.status === 409) {
302
+ this.ssl.createError = { step: 'port 80 check', cause: r.data.detail, consequence: r.data.hint, nginxRunning: true };
303
+ } else {
304
+ this.ssl.createError = r.data.error || { step: 'certificate issuance', cause: 'Unknown error', consequence: 'No certificate was issued.' };
305
+ }
306
+ },
307
+
276
308
  certStatus(cert) {
277
309
  if (cert.daysLeft === null || cert.daysLeft === undefined) return 'Unknown';
278
310
  if (cert.daysLeft > 30) return 'Healthy';
@@ -323,6 +355,8 @@ createApp({
323
355
  this.domains.editingName = null;
324
356
  this.domains.dirty = false;
325
357
  this.domains.error = '';
358
+ this.domains.certMissing = null;
359
+ this.domains.certCreateError = null;
326
360
  // Reset sections
327
361
  this.sections = {
328
362
  basic: true,
@@ -422,11 +456,50 @@ createApp({
422
456
  this.domains.editingName = null;
423
457
  this.resetDomainForm();
424
458
  await this.loadDomains();
459
+ } else if (r.status === 422 && r.data.error === 'cert_missing') {
460
+ this.domains.certMissing = r.data;
461
+ this.domains.certCreateError = null;
425
462
  } else {
426
463
  this.domains.error = r.data.error || 'Failed to save domain';
427
464
  }
428
465
  },
429
466
 
467
+ async createCertAndRetry() {
468
+ this.domains.certCreating = true;
469
+ this.domains.certCreateError = null;
470
+ const domain = this.domains.form.name;
471
+ const www = this.domains.form.www;
472
+ const r = await this.api('POST', '/api/ssl/create', { domain, www });
473
+ this.domains.certCreating = false;
474
+
475
+ if (r.ok) {
476
+ // Update cert paths in the form with what certbot actually wrote
477
+ this.domains.form.ssl.certPath = r.data.certPath;
478
+ this.domains.form.ssl.keyPath = r.data.keyPath;
479
+ this.domains.certMissing = null;
480
+ // Retry the domain save now that the cert exists
481
+ await this.saveDomain();
482
+ } else if (r.status === 503) {
483
+ this.domains.certCreateError = { step: 'ACME client detection', cause: r.data.hint, consequence: 'Install certbot or win-acme first.', nginxRunning: true };
484
+ } else if (r.status === 409) {
485
+ this.domains.certCreateError = { step: 'port 80 check', cause: r.data.detail, consequence: r.data.hint, nginxRunning: true };
486
+ } else {
487
+ this.domains.certCreateError = r.data.error || { step: 'certificate issuance', cause: 'Unknown error', consequence: 'No certificate was issued.' };
488
+ }
489
+ },
490
+
491
+ disableSslAndSave() {
492
+ this.domains.form.ssl.enabled = false;
493
+ this.domains.certMissing = null;
494
+ this.domains.certCreateError = null;
495
+ this.saveDomain();
496
+ },
497
+
498
+ dismissCertMissing() {
499
+ this.domains.certMissing = null;
500
+ this.domains.certCreateError = null;
501
+ },
502
+
430
503
  async deleteDomain(name) {
431
504
  if (!confirm(`Delete domain "${name}"? This cannot be undone.`)) return;
432
505
  await this.api('DELETE', `/api/domains/${name}`);
@@ -156,6 +156,20 @@ router.post('/', async (req, res) => {
156
156
  },
157
157
  });
158
158
 
159
+ // Cert existence check (FR-001): prevent saving a config that references non-existent cert files
160
+ if (domain.ssl.enabled && domain.ssl.certPath) {
161
+ try {
162
+ await fs.access(domain.ssl.certPath, fs.constants.F_OK);
163
+ } catch {
164
+ return res.status(422).json({
165
+ error: 'cert_missing',
166
+ certPath: domain.ssl.certPath,
167
+ keyPath: domain.ssl.keyPath,
168
+ hint: 'The SSL certificate files do not exist at the configured paths. Create the certificate first, or disable SSL.',
169
+ });
170
+ }
171
+ }
172
+
159
173
  const { nginxDir } = loadConfig();
160
174
 
161
175
  try {
@@ -1,6 +1,7 @@
1
1
  import express from 'express';
2
2
  import { run } from '../../core/shell.js';
3
3
  import { listAllCerts } from '../lib/cert-reader.js';
4
+ import { issueCert } from '../../cli/managers/ssl-manager.js';
4
5
 
5
6
  const router = express.Router();
6
7
 
@@ -48,6 +49,40 @@ async function renewDomain(domain, certbotCmd) {
48
49
  return { success: certResult.success, output };
49
50
  }
50
51
 
52
+ // ─── POST /api/ssl/create ─────────────────────────────────────────────────────
53
+
54
+ router.post('/create', async (req, res) => {
55
+ const { domain, www = false } = req.body ?? {};
56
+
57
+ if (!domain || typeof domain !== 'string' || !domain.trim()) {
58
+ return res.status(400).json({ error: 'domain is required' });
59
+ }
60
+
61
+ const result = await issueCert(domain.trim(), { www: !!www });
62
+
63
+ if (result.success) {
64
+ return res.json({ success: true, certPath: result.certPath, keyPath: result.keyPath });
65
+ }
66
+
67
+ const { step } = result.error;
68
+ if (step === 'ACME client detection') {
69
+ return res.status(503).json({
70
+ error: 'no_acme_client',
71
+ hint: 'Install certbot or win-acme first using the SSL Manager.',
72
+ });
73
+ }
74
+ if (step === 'port 80 check') {
75
+ return res.status(409).json({
76
+ error: 'port_busy',
77
+ detail: result.error.cause,
78
+ hint: 'Stop the process using port 80 and try again.',
79
+ });
80
+ }
81
+ return res.status(500).json({ success: false, error: result.error });
82
+ });
83
+
84
+ // ─── GET /api/ssl ─────────────────────────────────────────────────────────────
85
+
51
86
  router.get('/', async (req, res) => {
52
87
  const certbotCmd = await getCertbotCmd();
53
88
  if (!certbotCmd) {
@@ -14,6 +14,34 @@
14
14
  {{ domains.error }}
15
15
  </p>
16
16
 
17
+ <!-- cert_missing 422 handler -->
18
+ <div v-if="domains.certMissing" class="mx-4 mt-4 p-4 rounded-lg bg-yellow-500/10 border border-yellow-500/20">
19
+ <p class="text-yellow-400 text-sm font-semibold mb-1">SSL certificate not found</p>
20
+ <p class="text-slate-400 text-xs mb-3 font-mono">{{ domains.certMissing.certPath }}</p>
21
+ <p class="text-slate-400 text-xs mb-4">{{ domains.certMissing.hint }}</p>
22
+
23
+ <!-- Structured error from a failed cert creation attempt -->
24
+ <div v-if="domains.certCreateError" class="mb-4 p-3 rounded-lg bg-red-500/10 border border-red-500/20 text-xs space-y-1">
25
+ <p class="text-red-400 font-semibold">Certificate creation failed</p>
26
+ <p class="text-slate-400"><span class="text-slate-300">Step:</span> {{ domains.certCreateError.step }}</p>
27
+ <p class="text-slate-400"><span class="text-slate-300">Cause:</span> {{ domains.certCreateError.cause }}</p>
28
+ <p class="text-slate-400"><span class="text-slate-300">Consequence:</span> {{ domains.certCreateError.consequence }}</p>
29
+ <p class="text-slate-400"><span class="text-slate-300">nginx running:</span> {{ domains.certCreateError.nginxRunning ? 'yes' : 'no' }}</p>
30
+ </div>
31
+
32
+ <div class="flex gap-2">
33
+ <button @click="createCertAndRetry()" :disabled="domains.certCreating" class="btn btn-primary btn-sm">
34
+ {{ domains.certCreating ? 'Creating...' : 'Create Certificate' }}
35
+ </button>
36
+ <button @click="disableSslAndSave()" :disabled="domains.certCreating" class="btn btn-secondary btn-sm">
37
+ Disable SSL
38
+ </button>
39
+ <button @click="dismissCertMissing()" :disabled="domains.certCreating" class="btn btn-secondary btn-sm">
40
+ Cancel
41
+ </button>
42
+ </div>
43
+ </div>
44
+
17
45
  <!-- Basic Section -->
18
46
  <div class="border-b border-slate-800">
19
47
  <div @click="toggleSection('basic')" class="section-header">
@@ -2,11 +2,53 @@
2
2
  <div v-show="page === 'ssl'" class="max-w-6xl mx-auto">
3
3
  <div class="flex items-center justify-between mb-2">
4
4
  <h2 class="text-2xl font-bold">SSL Certificates</h2>
5
- <button @click="renewAll" :disabled="ssl.renewingDomain !== null" class="btn btn-primary btn-sm">
6
- {{ ssl.renewingDomain === 'all' ? 'Renewing...' : 'Renew Expiring' }}
7
- </button>
5
+ <div class="flex gap-2">
6
+ <button @click="ssl.showCreateForm = !ssl.showCreateForm; ssl.createResult = null; ssl.createError = null" class="btn btn-secondary btn-sm">
7
+ {{ ssl.showCreateForm ? 'Cancel' : 'New Certificate' }}
8
+ </button>
9
+ <button @click="renewAll" :disabled="ssl.renewingDomain !== null" class="btn btn-primary btn-sm">
10
+ {{ ssl.renewingDomain === 'all' ? 'Renewing...' : 'Renew Expiring' }}
11
+ </button>
12
+ </div>
13
+ </div>
14
+ <p class="text-slate-400 mb-4">Let's Encrypt certificates managed by certbot</p>
15
+
16
+ <!-- New Certificate inline form -->
17
+ <div v-if="ssl.showCreateForm" class="card p-4 mb-6">
18
+ <h3 class="font-semibold mb-3 text-sm">Create New Certificate</h3>
19
+ <div class="flex items-end gap-3 flex-wrap">
20
+ <div class="input-group flex-1 min-w-48">
21
+ <input v-model="ssl.createDomain" placeholder=" " @keyup.enter="createCert()" />
22
+ <label>Domain name</label>
23
+ </div>
24
+ <div class="flex items-center gap-2 pb-1">
25
+ <label class="switch">
26
+ <input type="checkbox" v-model="ssl.createWww" />
27
+ <span class="slider"></span>
28
+ </label>
29
+ <span class="text-sm text-slate-400">Include www</span>
30
+ </div>
31
+ <button @click="createCert()" :disabled="ssl.creating || !ssl.createDomain.trim()" class="btn btn-primary btn-sm">
32
+ {{ ssl.creating ? 'Creating...' : 'Create' }}
33
+ </button>
34
+ </div>
35
+
36
+ <!-- Success result -->
37
+ <div v-if="ssl.createResult" class="mt-3 p-3 rounded-lg bg-green-500/10 border border-green-500/20 text-xs">
38
+ <p class="text-green-400 font-semibold mb-1">Certificate created successfully</p>
39
+ <p class="text-slate-400 font-mono">Cert: {{ ssl.createResult.certPath }}</p>
40
+ <p class="text-slate-400 font-mono">Key: {{ ssl.createResult.keyPath }}</p>
41
+ </div>
42
+
43
+ <!-- Structured error -->
44
+ <div v-if="ssl.createError" class="mt-3 p-3 rounded-lg bg-red-500/10 border border-red-500/20 text-xs space-y-1">
45
+ <p class="text-red-400 font-semibold">Certificate creation failed</p>
46
+ <p class="text-slate-400"><span class="text-slate-300">Step:</span> {{ ssl.createError.step }}</p>
47
+ <p class="text-slate-400"><span class="text-slate-300">Cause:</span> {{ ssl.createError.cause }}</p>
48
+ <p class="text-slate-400"><span class="text-slate-300">Consequence:</span> {{ ssl.createError.consequence }}</p>
49
+ <p class="text-slate-400"><span class="text-slate-300">nginx running:</span> {{ ssl.createError.nginxRunning ? 'yes' : 'no' }}</p>
50
+ </div>
8
51
  </div>
9
- <p class="text-slate-400 mb-8">Let's Encrypt certificates managed by certbot</p>
10
52
 
11
53
  <div v-if="ssl.error" class="card p-4 mb-6 bg-red-500/10 border-red-500/20 text-red-400">
12
54
  {{ ssl.error }}
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "easy-devops",
3
- "version": "0.2.6",
3
+ "version": "0.2.7",
4
4
  "description": "A unified DevOps management tool with CLI and web dashboard for managing Nginx, SSL certificates, and Node.js on Linux and Windows servers.",
5
5
  "keywords": [
6
6
  "devops",