@webhikers/cli 1.0.1 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webhikers/cli",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "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

@@ -1,10 +1,11 @@
 import { execSync } from "child_process";
-import { existsSync, writeFileSync } from "fs";
+import { existsSync, writeFileSync, readFileSync } from "fs";
 import { resolve } from "path";
 import { loadConfig, getConfigPath } from "../utils/config-store.js";
 
 const TEMPLATE_REPO = "Webhikers/nextjs-vibe-starter";
 const GITHUB_ORG = "Webhikers";
+const DOMAIN_SUFFIX = "preview.webhikers.dev";
 
 function run(cmd, options = {}) {
   console.log(`  → ${cmd}`);
@@ -15,6 +16,28 @@ function runCapture(cmd) {
   return execSync(cmd, { encoding: "utf-8" }).trim();
 }
 
+async function coolifyApi(config, method, path, body) {
+  const url = `${config.coolifyUrl}/api/v1${path}`;
+  const options = {
+    method,
+    headers: {
+      Authorization: `Bearer ${config.coolifyToken}`,
+      "Content-Type": "application/json",
+    },
+  };
+  if (body) options.body = JSON.stringify(body);
+
+  const res = await fetch(url, options);
+  const data = await res.json();
+
+  if (!res.ok) {
+    throw new Error(
+      `Coolify API error (${res.status}): ${JSON.stringify(data)}`
+    );
+  }
+  return data;
+}
+
 export async function createCommand(name) {
   console.log(`\nCreating project: ${name}\n`);
 
@@ -61,6 +84,8 @@ export async function createCommand(name) {
   // --- 4. Generate .env ---
   console.log("\nGenerating .env...");
   const payloadSecret = runCapture("openssl rand -hex 32");
+  const domain = `${name}.${DOMAIN_SUFFIX}`;
+  const siteUrl = `https://${domain}`;
   const envContent = [
     `PAYLOAD_SECRET=${payloadSecret}`,
     `SITE_URL=http://localhost:3000`,
@@ -70,18 +95,85 @@ export async function createCommand(name) {
   writeFileSync(resolve(projectDir, ".env"), envContent, "utf-8");
   console.log("  .env written (PAYLOAD_SECRET + SITE_URL)");
 
-  // --- 5. Setup Coolify deployment ---
+  // --- 5. Get git remote URL ---
+  let gitRepo;
+  try {
+    gitRepo = runCapture("git remote get-url origin", { cwd: projectDir });
+  } catch {
+    console.error("Error: No git remote 'origin' found.");
+    process.exit(1);
+  }
+
+  // --- 6. Setup Coolify deployment ---
   console.log("\nSetting up Coolify deployment...");
-  run(`npm run setup:deploy -- --name ${name}`, { cwd: projectDir });
+  console.log(`  Domain: ${domain}`);
+  console.log(`  Git repo: ${gitRepo}`);
+
+  // Create project
+  console.log("  Creating Coolify project...");
+  const project = await coolifyApi(config, "POST", "/projects", {
+    name,
+    description: `${name} — deployed via webhikers CLI`,
+  });
+  const projectUuid = project.uuid;
+  console.log(`  Project created: ${projectUuid}`);
+
+  // Create application
+  console.log("  Creating application...");
+  const app = await coolifyApi(config, "POST", "/applications/public", {
+    project_uuid: projectUuid,
+    server_uuid: config.serverUuid,
+    environment_name: "production",
+    git_repository: gitRepo,
+    git_branch: "master",
+    build_pack: "dockerfile",
+    ports_exposes: "3000",
+    instant_deploy: false,
+  });
+  const appUuid = app.uuid;
+  console.log(`  Application created: ${appUuid}`);
+
+  // Set domain
+  console.log(`  Setting domain to ${domain}...`);
+  await coolifyApi(config, "PATCH", `/applications/${appUuid}`, {
+    domains: `https://${domain}`,
+  });
+
+  // Set environment variables
+  console.log("  Setting environment variables...");
+  await coolifyApi(config, "POST", `/applications/${appUuid}/envs`, {
+    key: "PAYLOAD_SECRET",
+    value: payloadSecret,
+    is_build_time: true,
+  });
+  await coolifyApi(config, "POST", `/applications/${appUuid}/envs`, {
+    key: "SITE_URL",
+    value: siteUrl,
+    is_build_time: true,
+  });
+
+  // --- 7. Write .deploy.json ---
+  const deployConfig = {
+    serverIp: config.serverIp,
+    domain,
+    coolifyProjectUuid: projectUuid,
+    coolifyAppUuid: appUuid,
+  };
+  writeFileSync(
+    resolve(projectDir, ".deploy.json"),
+    JSON.stringify(deployConfig, null, 2) + "\n",
+    "utf-8"
+  );
+  console.log("  .deploy.json written");
 
-  // --- 6. Summary ---
+  // --- 8. Summary ---
   console.log("");
   console.log("=========================================");
   console.log("  Project created successfully!");
   console.log("=========================================");
   console.log("");
   console.log(`  Repo:    https://github.com/${GITHUB_ORG}/${name}`);
-  console.log(`  Domain:  https://${name}.preview.webhikers.dev`);
+  console.log(`  Domain:  https://${domain}`);
   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;
 }