@webhikers/cli 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webhikers/cli",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "CLI for creating and deploying webhikers projects",
   "type": "module",
   "bin": {

package/src/commands/config.js

@@ -5,19 +5,21 @@ import {
   maskValue,
   getConfigPath,
 } from "../utils/config-store.js";
-import { saveSSHKey, getSSHKeyPath } from "../utils/ssh-key.js";
+import { findSSHKeys } from "../utils/ssh-key.js";
+
+const DEFAULT_COOLIFY_PORT = "8000";
 
 export async function configCommand() {
   const existing = loadConfig();
 
   if (existing) {
     console.log("\nExisting configuration found:");
-    console.log(`  Coolify URL:    ${existing.coolifyUrl || "—"}`);
+    console.log(`  Server IP:      ${existing.serverIp || "—"}`);
+    console.log(`  Coolify Port:   ${existing.coolifyPort || DEFAULT_COOLIFY_PORT}`);
     console.log(`  Coolify Token:  ${maskValue(existing.coolifyToken)}`);
     console.log(`  Server UUID:    ${maskValue(existing.serverUuid)}`);
-    console.log(`  Server IP:      ${existing.serverIp || "—"}`);
     console.log(`  SSH User:       ${existing.sshUser || "—"}`);
-    console.log(`  SSH Key:        ${getSSHKeyPath()}`);
+    console.log(`  SSH Key:        ${existing.sshKeyPath || "—"}`);
     console.log("");
 
     const { overwrite } = await inquirer.prompt([
@@ -35,62 +37,96 @@ export async function configCommand() {
     }
   }
 
+  // --- SSH Key selection ---
+  const sshKeys = findSSHKeys();
+  let sshKeyPath;
+
+  if (sshKeys.length > 0) {
+    const sshChoices = [
+      ...sshKeys,
+      { name: "Enter path manually", value: "__manual__" },
+    ];
+
+    const { selectedKey } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "selectedKey",
+        message: "SSH Key auswählen:",
+        choices: sshChoices,
+      },
+    ]);
+
+    if (selectedKey === "__manual__") {
+      const { manualPath } = await inquirer.prompt([
+        {
+          type: "input",
+          name: "manualPath",
+          message: "SSH Key Pfad:",
+          validate: (v) => (v.length > 0 ? true : "Pfad ist erforderlich"),
+        },
+      ]);
+      sshKeyPath = manualPath;
+    } else {
+      sshKeyPath = selectedKey;
+    }
+  } else {
+    console.log("\nKein SSH Key gefunden. Erstelle einen:");
+    console.log("  ssh-keygen -t ed25519 -f ~/.ssh/hetzner");
+    console.log("Dann füge ~/.ssh/hetzner.pub bei Hetzner hinzu:");
+    console.log("  Hetzner Console → Security → SSH Keys → Add\n");
+    process.exit(1);
+  }
+
+  // --- Server + Coolify config ---
   const answers = await inquirer.prompt([
     {
       type: "input",
-      name: "coolifyUrl",
-      message: "Coolify URL (e.g. https://coolify.your-server.de):",
-      validate: (v) => (v.startsWith("http") ? true : "Must start with http"),
+      name: "serverIp",
+      message: "Server IP-Adresse:\n  (Hetzner Cloud Console → Server → IP-Adresse)\n ",
+      validate: (v) => (v.length > 0 ? true : "IP ist erforderlich"),
+    },
+    {
+      type: "input",
+      name: "coolifyPort",
+      message: "Coolify Port:\n  (Standard ist 8000, Enter drücken wenn korrekt)\n ",
+      default: DEFAULT_COOLIFY_PORT,
     },
     {
       type: "password",
       name: "coolifyToken",
-      message: "Coolify API Token:",
+      message: "Coolify API Token:\n  (Coolify UI → Keys & Tokens → API Token erstellen)\n ",
       mask: "*",
-      validate: (v) => (v.length > 0 ? true : "Token is required"),
+      validate: (v) => (v.length > 0 ? true : "Token ist erforderlich"),
     },
     {
       type: "input",
       name: "serverUuid",
-      message: "Server UUID (from Coolify UI → Servers):",
-      validate: (v) => (v.length > 0 ? true : "Server UUID is required"),
-    },
-    {
-      type: "input",
-      name: "serverIp",
-      message: "Server IP address:",
-      validate: (v) => (v.length > 0 ? true : "Server IP is required"),
+      message: "Server UUID:\n  (Coolify UI → Servers → auf Server klicken → UUID steht in der URL)\n ",
+      validate: (v) => (v.length > 0 ? true : "UUID ist erforderlich"),
     },
     {
       type: "input",
       name: "sshUser",
-      message: "SSH User:",
+      message: "SSH User:\n  (Standard ist root, Enter drücken wenn korrekt)\n ",
       default: "root",
     },
-    {
-      type: "editor",
-      name: "sshKey",
-      message:
-        "SSH Private Key (your editor will open — paste the key, save, and close):",
-      validate: (v) =>
-        v.includes("PRIVATE KEY") ? true : "Does not look like a valid SSH key",
-    },
   ]);
 
-  const keyPath = saveSSHKey(answers.sshKey);
+  const coolifyUrl = `http://${answers.serverIp}:${answers.coolifyPort}`;
 
   const config = {
-    coolifyUrl: answers.coolifyUrl.replace(/\/+$/, ""),
+    serverIp: answers.serverIp,
+    coolifyPort: answers.coolifyPort,
+    coolifyUrl,
     coolifyToken: answers.coolifyToken,
     serverUuid: answers.serverUuid,
-    serverIp: answers.serverIp,
     sshUser: answers.sshUser,
-    sshKeyPath: keyPath,
+    sshKeyPath,
   };
 
   saveConfig(config);
 
   console.log(`\nConfiguration saved to ${getConfigPath()}`);
-  console.log(`SSH key saved to ${keyPath}`);
+  console.log(`Coolify URL: ${coolifyUrl}`);
   console.log("\nDone! You can now run: webhikers create <project-name>");
 }

package/src/commands/create.js

@@ -81,7 +81,7 @@ export async function createCommand(name) {
   console.log("=========================================");
   console.log("");
   console.log(`  Repo:    https://github.com/${GITHUB_ORG}/${name}`);
-  console.log(`  Domain:  https://${name}.webhikers.site`);
+  console.log(`  Domain:  https://${name}.preview.webhikers.dev`);
   console.log(`  Dir:     ${projectDir}`);
   console.log("");
   console.log("  MANUAL STEP:");

package/src/utils/ssh-key.js

@@ -1,17 +1,39 @@
-import { writeFileSync, chmodSync } from "fs";
+import { readdirSync, readFileSync, existsSync } from "fs";
 import { join } from "path";
-import { getConfigDir } from "./config-store.js";
+import { homedir } from "os";
 
-const SSH_KEY_FILENAME = "ssh_key";
+const SSH_DIR = join(homedir(), ".ssh");
 
-export function getSSHKeyPath() {
-  return join(getConfigDir(), SSH_KEY_FILENAME);
-}
+export function findSSHKeys() {
+  if (!existsSync(SSH_DIR)) return [];
+
+  const files = readdirSync(SSH_DIR);
+  const keys = [];
+
+  for (const file of files) {
+    if (file.endsWith(".pub")) continue;
+    if (file === "known_hosts" || file === "config" || file === "authorized_keys") continue;
+    if (file.startsWith(".")) continue;
+
+    const privatePath = join(SSH_DIR, file);
+    const pubPath = privatePath + ".pub";
+
+    if (!existsSync(pubPath)) continue;
+
+    let comment = "";
+    try {
+      const pubContent = readFileSync(pubPath, "utf-8").trim();
+      const parts = pubContent.split(" ");
+      if (parts.length >= 3) {
+        comment = parts.slice(2).join(" ");
+      }
+    } catch {}
+
+    keys.push({
+      name: `~/.ssh/${file}${comment ? ` (${comment})` : ""}`,
+      value: privatePath,
+    });
+  }
 
-export function saveSSHKey(keyContent) {
-  const keyPath = getSSHKeyPath();
-  const normalized = keyContent.trim() + "\n";
-  writeFileSync(keyPath, normalized, "utf-8");
-  chmodSync(keyPath, 0o600);
-  return keyPath;
+  return keys;
 }