@turboops/cli 1.0.0-dev.579 → 1.0.0-dev.582

package/dist/index.js

@@ -6,6 +6,8 @@ import chalk8 from "chalk";
 
 // src/services/config.ts
 import Conf from "conf";
+import * as fs from "fs";
+import * as path from "path";
 
 // src/utils/logger.ts
 import chalk from "chalk";
@@ -133,9 +135,9 @@ function loadPackageJson() {
     join(__dirname, "../package.json")
     // From dist/
   ];
-  for (const path of paths) {
-    if (existsSync(path)) {
-      return require2(path);
+  for (const path2 of paths) {
+    if (existsSync(path2)) {
+      return require2(path2);
     }
   }
   return { version: "0.0.0", name: "@turboops/cli" };
@@ -196,90 +198,150 @@ var API_URLS = {
   production: "https://api.turbo-ops.de",
   dev: "https://api.dev.turbo-ops.de"
 };
-function getDefaultApiUrl() {
-  const version = getCurrentVersion();
-  const isDevVersion = version.includes("-dev");
-  return isDevVersion ? API_URLS.dev : API_URLS.production;
-}
-var defaults = {
-  apiUrl: API_URLS.production,
+var APP_URLS = {
+  production: "https://turbo-ops.de",
+  dev: "https://dev.turbo-ops.de"
+};
+var LOCAL_CONFIG_FILE = ".turboops.json";
+var globalDefaults = {
   token: null,
-  project: null,
   userId: null
 };
-var config = new Conf({
+var globalConfig = new Conf({
   projectName: "turboops-cli",
-  defaults
+  defaults: globalDefaults
 });
+function findProjectRoot() {
+  let currentDir = process.cwd();
+  const root = path.parse(currentDir).root;
+  while (currentDir !== root) {
+    if (fs.existsSync(path.join(currentDir, LOCAL_CONFIG_FILE))) {
+      return currentDir;
+    }
+    if (fs.existsSync(path.join(currentDir, ".git"))) {
+      return currentDir;
+    }
+    if (fs.existsSync(path.join(currentDir, "package.json"))) {
+      return currentDir;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  return null;
+}
+function getLocalConfigPath() {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    return null;
+  }
+  return path.join(projectRoot, LOCAL_CONFIG_FILE);
+}
+function readLocalConfig() {
+  const configPath = getLocalConfigPath();
+  if (!configPath || !fs.existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeLocalConfig(config) {
+  const projectRoot = findProjectRoot() || process.cwd();
+  const configPath = path.join(projectRoot, LOCAL_CONFIG_FILE);
+  try {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    return true;
+  } catch (error) {
+    logger.error(`Failed to write ${LOCAL_CONFIG_FILE}: ${error}`);
+    return false;
+  }
+}
+function getApiUrl() {
+  const version = getCurrentVersion();
+  const isDevVersion = version.includes("-dev");
+  return isDevVersion ? API_URLS.dev : API_URLS.production;
+}
 var configService = {
   /**
-   * Get API URL
-   * Priority: ENV variable > stored config > version-based default
+   * Get API URL (fixed based on CLI version)
    */
   getApiUrl() {
     if (process.env.TURBOOPS_API_URL) {
       return process.env.TURBOOPS_API_URL;
     }
-    const storedUrl = config.get("apiUrl");
-    if (storedUrl === "https://api.turboops.io" || storedUrl === API_URLS.production) {
-      return getDefaultApiUrl();
-    }
-    return storedUrl;
+    return getApiUrl();
   },
   /**
-   * Set API URL
+   * Get App URL (frontend)
+   * Returns the appropriate frontend URL based on CLI version
    */
-  setApiUrl(url) {
-    config.set("apiUrl", url);
+  getAppUrl() {
+    const version = getCurrentVersion();
+    const isDevVersion = version.includes("-dev");
+    return isDevVersion ? APP_URLS.dev : APP_URLS.production;
   },
   /**
-   * Get authentication token
+   * Get authentication token (global - user session)
    */
   getToken() {
-    return process.env.TURBOOPS_TOKEN || config.get("token");
+    return process.env.TURBOOPS_TOKEN || globalConfig.get("token");
   },
   /**
-   * Set authentication token
+   * Set authentication token (global - user session)
    */
   setToken(token) {
-    config.set("token", token);
+    globalConfig.set("token", token);
   },
   /**
    * Clear authentication token
    */
   clearToken() {
-    config.set("token", null);
-    config.set("userId", null);
+    globalConfig.set("token", null);
+    globalConfig.set("userId", null);
   },
   /**
-   * Get current project
+   * Get current project (local - project specific)
    */
   getProject() {
-    return process.env.TURBOOPS_PROJECT || config.get("project");
+    if (process.env.TURBOOPS_PROJECT) {
+      return process.env.TURBOOPS_PROJECT;
+    }
+    const localConfig = readLocalConfig();
+    return localConfig?.project || null;
   },
   /**
-   * Set current project
+   * Set current project (local - writes to .turboops.json)
    */
   setProject(project) {
-    config.set("project", project);
+    const localConfig = readLocalConfig() || { project: "" };
+    localConfig.project = project;
+    writeLocalConfig(localConfig);
   },
   /**
    * Clear current project
    */
   clearProject() {
-    config.set("project", null);
+    const configPath = getLocalConfigPath();
+    if (configPath && fs.existsSync(configPath)) {
+      try {
+        fs.unlinkSync(configPath);
+      } catch {
+      }
+    }
   },
   /**
-   * Get user ID
+   * Get user ID (global - user session)
    */
   getUserId() {
-    return config.get("userId");
+    return globalConfig.get("userId");
   },
   /**
-   * Set user ID
+   * Set user ID (global - user session)
    */
   setUserId(userId) {
-    config.set("userId", userId);
+    globalConfig.set("userId", userId);
   },
   /**
    * Check if user is authenticated
@@ -293,6 +355,19 @@ var configService = {
   hasProject() {
     return !!this.getProject();
   },
+  /**
+   * Check if local config exists
+   */
+  hasLocalConfig() {
+    const configPath = getLocalConfigPath();
+    return !!configPath && fs.existsSync(configPath);
+  },
+  /**
+   * Get local config file path (for display purposes)
+   */
+  getLocalConfigPath() {
+    return getLocalConfigPath();
+  },
   /**
    * Get all configuration
    */
@@ -305,17 +380,25 @@ var configService = {
     };
   },
   /**
-   * Clear all configuration
+   * Clear all configuration (both global and local)
    */
   clearAll() {
-    config.clear();
+    globalConfig.clear();
+    this.clearProject();
   },
   /**
-   * Check if using a project token (turbo_xxx format)
+   * Check if using a project token (turbo_xxx format, but not turbo_cli_xxx)
    */
   isProjectToken() {
     const token = this.getToken();
-    return !!token && token.startsWith("turbo_");
+    return !!token && token.startsWith("turbo_") && !token.startsWith("turbo_cli_");
+  },
+  /**
+   * Check if using a CLI session token (turbo_cli_xxx format)
+   */
+  isCliSessionToken() {
+    const token = this.getToken();
+    return !!token && token.startsWith("turbo_cli_");
   },
   /**
    * Show current configuration
@@ -323,12 +406,15 @@ var configService = {
   show() {
     const data = this.getAll();
     const isProjectToken2 = this.isProjectToken();
+    const isCliToken = this.isCliSessionToken();
+    const localConfigPath = this.getLocalConfigPath();
     logger.header("Configuration");
     logger.table({
       "API URL": data.apiUrl,
       Token: data.token || "Not set",
-      "Token Type": isProjectToken2 ? "Project Token" : data.token ? "User Token" : "N/A",
+      "Token Type": isProjectToken2 ? "Project Token (CI/CD)" : isCliToken ? "CLI Session Token" : data.token ? "User Token" : "N/A",
       Project: data.project || (isProjectToken2 ? "(from token)" : "Not set"),
+      "Project Config": localConfigPath || "(not found)",
       "User ID": data.userId || (isProjectToken2 ? "(N/A for project token)" : "Not set")
     });
   }
@@ -336,7 +422,6 @@ var configService = {
 
 // src/commands/login.ts
 import { Command } from "commander";
-import prompts from "prompts";
 
 // src/services/api.ts
 function isProjectToken(token) {
@@ -347,7 +432,7 @@ var apiClient = {
   /**
    * Make an API request
    */
-  async request(method, path, body) {
+  async request(method, path2, body) {
     const apiUrl = configService.getApiUrl();
     const token = configService.getToken();
     if (!token) {
@@ -356,7 +441,7 @@ var apiClient = {
         status: 401
       };
     }
-    const url = `${apiUrl}${path}`;
+    const url = `${apiUrl}${path2}`;
     const headers = {
       "Content-Type": "application/json",
       Authorization: `Bearer ${token}`
@@ -501,23 +586,66 @@ var apiClient = {
     return this.request("GET", `/deployment/projects/by-slug/${slug}`);
   },
   /**
-   * Get environments for project
+   * Create a new project
+   */
+  async createProject(data) {
+    const payload = {
+      name: data.name,
+      slug: data.slug
+    };
+    if (data.customer) payload.customer = data.customer;
+    if (data.description) payload.description = data.description;
+    if (data.repositoryUrl) payload.repositoryUrl = data.repositoryUrl;
+    return this.request("POST", "/deployment/projects/simple", payload);
+  },
+  /**
+   * Get all customers
+   */
+  async getCustomers() {
+    return this.request("GET", "/customer");
+  },
+  /**
+   * Get environments (stages) for project
    */
   async getEnvironments(projectId) {
     return this.request(
       "GET",
-      `/deployment/environments?projectId=${projectId}`
+      `/deployment/stages?projectId=${projectId}`
     );
   },
   /**
-   * Get environment by slug
+   * Get environment (stage) by slug
    */
   async getEnvironmentBySlug(projectId, slug) {
     return this.request(
       "GET",
-      `/deployment/environments/by-slug/${projectId}/${slug}`
+      `/deployment/stages/by-slug/${projectId}/${slug}`
     );
   },
+  /**
+   * Create a new stage
+   */
+  async createStage(data) {
+    return this.request("POST", "/deployment/stages/simple", data);
+  },
+  /**
+   * Get deployment-ready servers
+   */
+  async getDeploymentServers() {
+    return this.request("GET", "/server?deploymentReady=true");
+  },
+  /**
+   * Generate CI/CD pipeline configuration
+   */
+  async generatePipeline(projectId, type) {
+    return this.request("GET", `/deployment/projects/${projectId}/pipeline/${type}`);
+  },
+  /**
+   * Get required secrets for pipeline
+   */
+  async getPipelineSecrets(projectId, type) {
+    return this.request("GET", `/deployment/projects/${projectId}/pipeline/${type}/secrets`);
+  },
   /**
    * Trigger deployment
    */
@@ -548,7 +676,7 @@ var apiClient = {
   async restart(environmentId) {
     return this.request(
       "POST",
-      `/deployment/environments/${environmentId}/restart`
+      `/deployment/stages/${environmentId}/restart`
     );
   },
   /**
@@ -557,7 +685,7 @@ var apiClient = {
   async stop(environmentId) {
     return this.request(
       "POST",
-      `/deployment/environments/${environmentId}/stop`
+      `/deployment/stages/${environmentId}/stop`
     );
   },
   /**
@@ -566,7 +694,7 @@ var apiClient = {
   async wake(environmentId) {
     return this.request(
       "POST",
-      `/deployment/environments/${environmentId}/wake`
+      `/deployment/stages/${environmentId}/wake`
     );
   },
   /**
@@ -581,7 +709,7 @@ var apiClient = {
   async getEnvVars(environmentId) {
     return this.request(
       "GET",
-      `/deployment/environments/${environmentId}/env-vars`
+      `/deployment/stages/${environmentId}/env-vars`
     );
   },
   /**
@@ -590,7 +718,7 @@ var apiClient = {
   async setEnvVar(environmentId, key, value, secret) {
     return this.request(
       "PUT",
-      `/deployment/environments/${environmentId}/env-vars`,
+      `/deployment/stages/${environmentId}/env-vars`,
       {
         key,
         value,
@@ -604,7 +732,7 @@ var apiClient = {
   async deleteEnvVar(environmentId, key) {
     return this.request(
       "DELETE",
-      `/deployment/environments/${environmentId}/env-vars/${key}`
+      `/deployment/stages/${environmentId}/env-vars/${key}`
     );
   },
   /**
@@ -634,6 +762,137 @@ var apiClient = {
   }
 };
 
+// src/services/auth.ts
+import os from "os";
+var authService = {
+  /**
+   * Start browser-based authentication flow
+   * Returns the auth code and URL for the browser
+   */
+  async initAuth() {
+    const apiUrl = configService.getApiUrl();
+    const version = getCurrentVersion();
+    const platform = os.platform();
+    const hostname = os.hostname();
+    try {
+      const response = await fetch(`${apiUrl}/cli/auth/init`, {
+        body: JSON.stringify({
+          cliVersion: version,
+          hostname,
+          platform
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        return null;
+      }
+      return await response.json();
+    } catch {
+      return null;
+    }
+  },
+  /**
+   * Poll for authentication status
+   */
+  async pollAuth(code, pollToken) {
+    const apiUrl = configService.getApiUrl();
+    try {
+      const response = await fetch(`${apiUrl}/cli/auth/poll/${code}`, {
+        headers: {
+          "X-Poll-Token": pollToken
+        }
+      });
+      if (!response.ok) {
+        return { status: "expired" };
+      }
+      return await response.json();
+    } catch {
+      return { status: "expired" };
+    }
+  },
+  /**
+   * Validate a CLI token
+   */
+  async validateToken(token) {
+    const apiUrl = configService.getApiUrl();
+    try {
+      const response = await fetch(`${apiUrl}/cli/auth/validate`, {
+        headers: {
+          Authorization: `Bearer ${token}`
+        }
+      });
+      if (!response.ok) {
+        return { valid: false };
+      }
+      return await response.json();
+    } catch {
+      return { valid: false };
+    }
+  },
+  /**
+   * Perform browser-based login
+   * Opens browser, waits for user to authorize, returns user info
+   */
+  async browserLogin() {
+    const open = (await import("open")).default;
+    logger.info("Initialisiere Anmeldung...");
+    const authInit = await this.initAuth();
+    if (!authInit) {
+      return { error: "Konnte Authentifizierung nicht initialisieren", success: false };
+    }
+    logger.newline();
+    logger.info("Bitte autorisieren Sie die CLI in Ihrem Browser.");
+    logger.newline();
+    logger.info(`Autorisierungscode: ${authInit.code}`);
+    logger.newline();
+    try {
+      await open(authInit.authUrl);
+      logger.info("Browser wurde ge\xF6ffnet...");
+    } catch {
+      logger.warning("Browser konnte nicht ge\xF6ffnet werden.");
+      logger.info(`Bitte \xF6ffnen Sie diese URL manuell: ${authInit.authUrl}`);
+    }
+    logger.newline();
+    logger.info("Warte auf Autorisierung...");
+    const maxAttempts = 150;
+    const pollInterval = 2e3;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const result = await this.pollAuth(authInit.code, authInit.pollToken);
+      if (result.status === "authorized" && result.token) {
+        configService.setToken(result.token);
+        if (result.user) {
+          configService.setUserId(result.user.id);
+        }
+        return {
+          success: true,
+          user: result.user
+        };
+      }
+      if (result.status === "expired" || result.status === "consumed") {
+        return { error: "Autorisierungscode abgelaufen oder bereits verwendet", success: false };
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    return { error: "Zeit\xFCberschreitung bei der Anmeldung", success: false };
+  },
+  /**
+   * Check if current token is a CLI token and validate it
+   */
+  async checkCliToken() {
+    const token = configService.getToken();
+    if (!token) {
+      return { valid: false };
+    }
+    if (!token.startsWith("turbo_cli_")) {
+      return { valid: true };
+    }
+    return await this.validateToken(token);
+  }
+};
+
 // src/utils/spinner.ts
 import ora from "ora";
 function createSpinner(text) {
@@ -660,60 +919,59 @@ var loginCommand = new Command("login").description("Authenticate with TurboOps
   logger.header("TurboOps Login");
   if (options.token) {
     configService.setToken(options.token);
-    const { data: data2, error: error2 } = await withSpinner(
+    if (options.token.startsWith("turbo_cli_")) {
+      const { data: data2, error: error2 } = await withSpinner("Verifying token...", async () => {
+        const result2 = await authService.validateToken(options.token);
+        if (result2.valid && result2.user) {
+          return { data: result2.user, error: void 0 };
+        }
+        return { data: void 0, error: "Invalid token" };
+      });
+      if (error2 || !data2) {
+        configService.clearToken();
+        logger.error(`Authentication failed: ${error2 || "Invalid token"}`);
+        process.exit(10 /* AUTH_ERROR */);
+      }
+      configService.setUserId(data2.id);
+      addJsonData({
+        authenticated: true,
+        user: { email: data2.email, id: data2.id }
+      });
+      logger.success(`Authenticated as ${data2.email}`);
+      return;
+    }
+    const { data, error } = await withSpinner(
       "Verifying token...",
       () => apiClient.whoami()
     );
-    if (error2 || !data2) {
+    if (error || !data) {
       configService.clearToken();
-      logger.error(`Authentication failed: ${error2 || "Invalid token"}`);
+      logger.error(`Authentication failed: ${error || "Invalid token"}`);
       process.exit(10 /* AUTH_ERROR */);
     }
-    configService.setUserId(data2.id);
+    configService.setUserId(data.id);
     addJsonData({
       authenticated: true,
-      user: { id: data2.id, email: data2.email }
+      user: { email: data.email, id: data.id }
     });
-    logger.success(`Authenticated as ${data2.email}`);
-    return;
-  }
-  const response = await prompts([
-    {
-      type: "text",
-      name: "email",
-      message: "Email:",
-      validate: (value) => value.includes("@") || "Please enter a valid email"
-    },
-    {
-      type: "password",
-      name: "password",
-      message: "Password:"
-    }
-  ]);
-  if (!response.email || !response.password) {
-    logger.warning("Login cancelled");
-    addJsonData({ authenticated: false, cancelled: true });
+    logger.success(`Authenticated as ${data.email}`);
     return;
   }
-  const { data, error } = await withSpinner(
-    "Logging in...",
-    () => apiClient.login(response.email, response.password)
-  );
-  if (error || !data) {
-    logger.error(`Login failed: ${error || "Unknown error"}`);
-    addJsonData({ authenticated: false, error: error || "Unknown error" });
+  const result = await authService.browserLogin();
+  if (!result.success) {
+    logger.error(`Login failed: ${result.error || "Unknown error"}`);
+    addJsonData({ authenticated: false, error: result.error || "Unknown error" });
     process.exit(10 /* AUTH_ERROR */);
   }
-  configService.setToken(data.token);
-  configService.setUserId(data.user.id);
   addJsonData({
     authenticated: true,
-    user: { id: data.user.id, email: data.user.email }
+    user: result.user ? { email: result.user.email, fullName: result.user.fullName, id: result.user.id } : void 0
   });
-  logger.success(`Logged in as ${data.user.email}`);
   logger.newline();
-  logger.info("Your credentials have been saved.");
-  logger.info("Run `turbo whoami` to verify your authentication.");
+  logger.success(`Angemeldet als ${result.user?.email || "Unknown"}`);
+  logger.newline();
+  logger.info("Ihre Anmeldedaten wurden gespeichert.");
+  logger.info("F\xFChren Sie `turbo whoami` aus, um Ihre Authentifizierung zu \xFCberpr\xFCfen.");
 });
 var logoutCommand = new Command("logout").description("Remove stored authentication").action(() => {
   configService.clearToken();
@@ -726,6 +984,36 @@ var whoamiCommand = new Command("whoami").description("Show current authenticate
     addJsonData({ authenticated: false });
     process.exit(10 /* AUTH_ERROR */);
   }
+  const token = configService.getToken();
+  if (token?.startsWith("turbo_cli_")) {
+    const { data: data2, error: error2 } = await withSpinner("Fetching user info...", async () => {
+      const result = await authService.validateToken(token);
+      if (result.valid && result.user) {
+        return { data: result.user, error: void 0 };
+      }
+      return { data: void 0, error: "Invalid token" };
+    });
+    if (error2 || !data2) {
+      logger.error(`Failed to fetch user info: ${error2 || "Unknown error"}`);
+      addJsonData({ authenticated: false, error: error2 || "Unknown error" });
+      process.exit(13 /* API_ERROR */);
+    }
+    addJsonData({
+      authenticated: true,
+      user: {
+        email: data2.email,
+        id: data2.id,
+        name: data2.fullName || null
+      }
+    });
+    logger.header("Current User");
+    logger.table({
+      Email: data2.email,
+      ID: data2.id,
+      Name: data2.fullName || "-"
+    });
+    return;
+  }
   const { data, error } = await withSpinner(
     "Fetching user info...",
     () => apiClient.whoami()
@@ -738,15 +1026,15 @@ var whoamiCommand = new Command("whoami").description("Show current authenticate
   addJsonData({
     authenticated: true,
     user: {
-      id: data.id,
       email: data.email,
+      id: data.id,
       name: data.name || null
     }
   });
   logger.header("Current User");
   logger.table({
-    ID: data.id,
     Email: data.email,
+    ID: data.id,
     Name: data.name || "-"
   });
 });
@@ -1034,11 +1322,77 @@ var statusCommand = new Command3("status").description("Show deployment status")
     });
   }
 });
-var configCommand = new Command3("config").description("Show current configuration").action(() => {
-  const config2 = configService.getAll();
-  addJsonData({ config: config2 });
+var configCommand = new Command3("config").description("Manage configuration");
+configCommand.command("show", { isDefault: true }).description("Show current configuration").action(() => {
+  const config = configService.getAll();
+  addJsonData({ config });
   configService.show();
 });
+configCommand.command("set").description("Set a configuration value").argument("<key>", "Configuration key (token, project)").argument("<value>", "Value to set").action((key, value) => {
+  switch (key.toLowerCase()) {
+    case "token":
+      configService.setToken(value);
+      logger.success("Token saved (global)");
+      addJsonData({ key: "token", saved: true, scope: "global" });
+      break;
+    case "project":
+      configService.setProject(value);
+      logger.success(`Project saved to .turboops.json`);
+      addJsonData({ key: "project", value, saved: true, scope: "local" });
+      break;
+    default:
+      logger.error(`Unknown config key: ${key}`);
+      logger.info("Available keys: token, project");
+      addJsonData({ error: `Unknown config key: ${key}` });
+      process.exit(14 /* VALIDATION_ERROR */);
+  }
+});
+configCommand.command("get").description("Get a configuration value").argument("<key>", "Configuration key (token, project, api-url)").action((key) => {
+  let value = null;
+  switch (key.toLowerCase()) {
+    case "token":
+      value = configService.getToken();
+      if (value) {
+        console.log("***");
+        addJsonData({ key: "token", set: true });
+      } else {
+        console.log("(not set)");
+        addJsonData({ key: "token", set: false });
+      }
+      return;
+    case "project":
+      value = configService.getProject();
+      break;
+    case "api-url":
+      value = configService.getApiUrl();
+      break;
+    default:
+      logger.error(`Unknown config key: ${key}`);
+      logger.info("Available keys: token, project, api-url");
+      addJsonData({ error: `Unknown config key: ${key}` });
+      process.exit(14 /* VALIDATION_ERROR */);
+  }
+  console.log(value || "(not set)");
+  addJsonData({ key, value });
+});
+configCommand.command("clear").description("Clear configuration").option("--all", "Clear all configuration").option("--token", "Clear token only").option("--project", "Clear project only").action((opts) => {
+  if (opts.all) {
+    configService.clearAll();
+    logger.success("All configuration cleared");
+    addJsonData({ cleared: "all" });
+  } else if (opts.token) {
+    configService.clearToken();
+    logger.success("Token cleared");
+    addJsonData({ cleared: "token" });
+  } else if (opts.project) {
+    configService.clearProject();
+    logger.success("Project configuration cleared");
+    addJsonData({ cleared: "project" });
+  } else {
+    logger.error("Specify what to clear: --all, --token, or --project");
+    process.exit(14 /* VALIDATION_ERROR */);
+  }
+});
 function getStatusColor(status) {
   switch (status) {
     case "healthy":
@@ -1151,130 +1505,377 @@ envCommand.addCommand(envUnsetCommand);
 
 // src/commands/init.ts
 import { Command as Command5 } from "commander";
-import prompts2 from "prompts";
+import prompts from "prompts";
 import chalk6 from "chalk";
 var initCommand = new Command5("init").description("Initialize TurboOps project in current directory").action(async () => {
   logger.header("TurboOps Project Initialization");
   if (!configService.isAuthenticated()) {
-    logger.warning("Not authenticated. Please log in first.");
+    logger.warning("Nicht authentifiziert. Bitte melden Sie sich zuerst an.");
     logger.newline();
-    const { shouldLogin } = await prompts2({
-      type: "confirm",
+    const { shouldLogin } = await prompts({
+      initial: true,
+      message: "M\xF6chten Sie sich jetzt anmelden?",
       name: "shouldLogin",
-      message: "Would you like to log in now?",
-      initial: true
+      type: "confirm"
     });
     if (!shouldLogin) {
-      logger.info("Run `turbo login` when ready.");
+      logger.info("F\xFChren Sie `turbo login` aus, wenn Sie bereit sind.");
       addJsonData({ initialized: false, reason: "not_authenticated" });
       return;
     }
-    const credentials = await prompts2([
-      {
-        type: "text",
-        name: "email",
-        message: "Email:",
-        validate: (value) => value.includes("@") || "Please enter a valid email"
-      },
-      {
-        type: "password",
-        name: "password",
-        message: "Password:"
-      }
-    ]);
-    if (!credentials.email || !credentials.password) {
-      logger.warning("Login cancelled");
-      addJsonData({ initialized: false, reason: "login_cancelled" });
-      return;
-    }
-    const { data, error } = await withSpinner(
-      "Logging in...",
-      () => apiClient.login(credentials.email, credentials.password)
-    );
-    if (error || !data) {
-      logger.error(`Login failed: ${error || "Unknown error"}`);
+    const result = await authService.browserLogin();
+    if (!result.success) {
+      logger.error(`Anmeldung fehlgeschlagen: ${result.error || "Unbekannter Fehler"}`);
       addJsonData({
+        error: result.error || "Unknown error",
         initialized: false,
-        reason: "login_failed",
-        error: error || "Unknown error"
+        reason: "login_failed"
       });
       process.exit(10 /* AUTH_ERROR */);
     }
-    configService.setToken(data.token);
-    configService.setUserId(data.user.id);
-    logger.success(`Logged in as ${data.user.email}`);
+    logger.success(`Angemeldet als ${result.user?.email || "Unknown"}`);
   }
   logger.newline();
-  const { projectSlug } = await prompts2({
-    type: "text",
+  const { projectSlug } = await prompts({
+    hint: "Der Slug Ihres TurboOps-Projekts",
+    message: "Projekt-Slug:",
     name: "projectSlug",
-    message: "Project slug:",
-    hint: "The slug of your TurboOps project",
-    validate: (value) => value.length > 0 || "Project slug is required"
+    type: "text",
+    validate: (value) => value.length > 0 || "Projekt-Slug ist erforderlich"
   });
   if (!projectSlug) {
-    logger.warning("Initialization cancelled");
+    logger.warning("Initialisierung abgebrochen");
     addJsonData({ initialized: false, reason: "cancelled" });
     return;
   }
   const { data: project, error: projectError } = await withSpinner(
-    "Verifying project...",
+    "Suche Projekt...",
     () => apiClient.getProject(projectSlug)
   );
-  if (projectError || !project) {
-    logger.error(
-      `Project "${projectSlug}" not found or you don't have access.`
-    );
-    logger.info(
-      "Make sure the project exists in TurboOps and you have permission to access it."
-    );
+  if (project) {
+    await setupProject(project);
+    return;
+  }
+  logger.newline();
+  logger.warning(`Projekt "${projectSlug}" nicht gefunden.`);
+  const { shouldCreate } = await prompts({
+    initial: true,
+    message: "M\xF6chten Sie ein neues Projekt anlegen?",
+    name: "shouldCreate",
+    type: "confirm"
+  });
+  if (!shouldCreate) {
+    logger.info("Initialisierung abgebrochen.");
+    addJsonData({ initialized: false, reason: "project_not_found" });
+    return;
+  }
+  await createNewProject(projectSlug);
+});
+async function setupProject(project) {
+  configService.setProject(project.slug);
+  const { data: environments } = await apiClient.getEnvironments(project.id);
+  if (!environments || environments.length === 0) {
+    logger.newline();
+    const { shouldCreateStage } = await prompts({
+      initial: true,
+      message: "Das Projekt hat noch keine Stages. M\xF6chten Sie jetzt eine erstellen?",
+      name: "shouldCreateStage",
+      type: "confirm"
+    });
+    if (shouldCreateStage) {
+      await createFirstStage(project.id, project.slug);
+    }
+  }
+  const fs2 = await import("fs/promises");
+  const path2 = await import("path");
+  const gitlabCiPath = path2.join(process.cwd(), ".gitlab-ci.yml");
+  let hasGitLabPipeline = false;
+  try {
+    await fs2.access(gitlabCiPath);
+    hasGitLabPipeline = true;
+  } catch {
+  }
+  if (!hasGitLabPipeline) {
+    logger.newline();
+    const { shouldCreatePipeline } = await prompts({
+      initial: false,
+      message: "M\xF6chten Sie eine CI/CD Pipeline anlegen?",
+      name: "shouldCreatePipeline",
+      type: "confirm"
+    });
+    if (shouldCreatePipeline) {
+      await createPipeline(project.id);
+    }
+  }
+  await showFinalSummary(project);
+}
+async function createNewProject(slug) {
+  logger.newline();
+  logger.header("Neues Projekt erstellen");
+  const { data: customers } = await withSpinner(
+    "Lade verf\xFCgbare Kunden...",
+    () => apiClient.getCustomers()
+  );
+  const promptQuestions = [
+    {
+      initial: slug.charAt(0).toUpperCase() + slug.slice(1).replace(/-/g, " "),
+      message: "Projektname:",
+      name: "name",
+      type: "text",
+      validate: (value) => value.length > 0 || "Projektname ist erforderlich"
+    }
+  ];
+  if (customers && customers.length > 0) {
+    promptQuestions.push({
+      choices: [
+        { title: "(Kein Kunde)", value: "" },
+        ...customers.map((c) => ({ title: c.name, value: c.id }))
+      ],
+      message: "Kunde (optional):",
+      name: "customer",
+      type: "select"
+    });
+  }
+  promptQuestions.push(
+    {
+      message: "Beschreibung (optional):",
+      name: "description",
+      type: "text"
+    },
+    {
+      message: "Repository URL (optional):",
+      name: "repositoryUrl",
+      type: "text"
+    }
+  );
+  const projectDetails = await prompts(promptQuestions);
+  if (!projectDetails.name) {
+    logger.warning("Projekterstellung abgebrochen");
+    addJsonData({ initialized: false, reason: "cancelled" });
+    return;
+  }
+  const { data: newProject, error: createError } = await withSpinner(
+    "Erstelle Projekt...",
+    () => apiClient.createProject({
+      customer: projectDetails.customer || void 0,
+      description: projectDetails.description || void 0,
+      name: projectDetails.name,
+      repositoryUrl: projectDetails.repositoryUrl || void 0,
+      slug
+    })
+  );
+  if (createError || !newProject) {
+    logger.error(`Projekt konnte nicht erstellt werden: ${createError || "Unbekannter Fehler"}`);
     addJsonData({
+      error: createError || "Unknown error",
       initialized: false,
-      reason: "project_not_found",
-      projectSlug
+      reason: "create_failed"
     });
-    process.exit(12 /* NOT_FOUND */);
+    process.exit(13 /* API_ERROR */);
+  }
+  logger.success(`Projekt "${newProject.name}" wurde erstellt!`);
+  configService.setProject(newProject.slug);
+  logger.newline();
+  const { shouldCreateStage } = await prompts({
+    initial: true,
+    message: "M\xF6chten Sie jetzt die erste Stage anlegen?",
+    name: "shouldCreateStage",
+    type: "confirm"
+  });
+  if (shouldCreateStage) {
+    await createFirstStage(newProject.id, newProject.slug);
+  }
+  logger.newline();
+  const { shouldCreatePipeline } = await prompts({
+    initial: true,
+    message: "M\xF6chten Sie eine CI/CD Pipeline anlegen?",
+    name: "shouldCreatePipeline",
+    type: "confirm"
+  });
+  if (shouldCreatePipeline) {
+    await createPipeline(newProject.id);
+  }
+  await showFinalSummary(newProject);
+}
+async function createFirstStage(projectId, projectSlug) {
+  logger.newline();
+  logger.header("Erste Stage erstellen");
+  const { data: servers } = await withSpinner(
+    "Lade verf\xFCgbare Server...",
+    () => apiClient.getDeploymentServers()
+  );
+  const stageTypes = [
+    { title: "Development", value: "development" },
+    { title: "Staging", value: "staging" },
+    { title: "Production", value: "production" }
+  ];
+  const stageQuestions = [
+    {
+      choices: stageTypes,
+      initial: 0,
+      message: "Stage-Typ:",
+      name: "type",
+      type: "select"
+    },
+    {
+      initial: (prev) => prev === "production" ? "Production" : prev === "staging" ? "Staging" : "Development",
+      message: "Stage-Name:",
+      name: "name",
+      type: "text",
+      validate: (value) => value.length > 0 || "Name ist erforderlich"
+    },
+    {
+      initial: (_prev, values) => values.type || "",
+      message: "Stage-Slug:",
+      name: "slug",
+      type: "text",
+      validate: (value) => value.length > 0 || "Slug ist erforderlich"
+    },
+    {
+      initial: (_prev, values) => `${values.slug || ""}.${projectSlug}.example.com`,
+      message: "Domain:",
+      name: "domain",
+      type: "text"
+    },
+    {
+      initial: (_prev, values) => values.type === "production" ? "main" : values.type === "staging" ? "staging" : "develop",
+      message: "Branch:",
+      name: "branch",
+      type: "text"
+    }
+  ];
+  if (servers && servers.length > 0) {
+    stageQuestions.push({
+      choices: [
+        { title: "(Sp\xE4ter ausw\xE4hlen)", value: "" },
+        ...servers.map((s) => ({ title: `${s.name} (${s.host})`, value: s.id }))
+      ],
+      message: "Server (optional):",
+      name: "server",
+      type: "select"
+    });
+  }
+  const stageDetails = await prompts(stageQuestions);
+  if (!stageDetails.name || !stageDetails.slug) {
+    logger.warning("Stage-Erstellung abgebrochen");
+    return;
+  }
+  const { data: newStage, error: stageError } = await withSpinner(
+    "Erstelle Stage...",
+    () => apiClient.createStage({
+      project: projectId,
+      name: stageDetails.name,
+      slug: stageDetails.slug,
+      type: stageDetails.type,
+      domain: stageDetails.domain || void 0,
+      server: stageDetails.server || void 0,
+      branch: stageDetails.branch || void 0
+    })
+  );
+  if (stageError || !newStage) {
+    logger.error(`Stage konnte nicht erstellt werden: ${stageError || "Unbekannter Fehler"}`);
+    return;
+  }
+  logger.success(`Stage "${newStage.name}" wurde erstellt!`);
+}
+async function createPipeline(projectId) {
+  logger.newline();
+  logger.header("CI/CD Pipeline erstellen");
+  const pipelineQuestions = [
+    {
+      choices: [
+        { title: "GitLab CI/CD", value: "gitlab" },
+        { title: "GitHub Actions", value: "github" }
+      ],
+      initial: 0,
+      message: "Pipeline-Typ:",
+      name: "pipelineType",
+      type: "select"
+    }
+  ];
+  const pipelineDetails = await prompts(pipelineQuestions);
+  if (!pipelineDetails.pipelineType) {
+    logger.warning("Pipeline-Erstellung abgebrochen");
+    return;
+  }
+  const { data: pipeline, error } = await withSpinner(
+    "Generiere Pipeline...",
+    () => apiClient.generatePipeline(projectId, pipelineDetails.pipelineType)
+  );
+  if (error || !pipeline) {
+    logger.error(`Pipeline konnte nicht generiert werden: ${error || "Unbekannter Fehler"}`);
+    return;
+  }
+  const fs2 = await import("fs/promises");
+  const path2 = await import("path");
+  let filePath;
+  if (pipelineDetails.pipelineType === "github") {
+    const workflowsDir = path2.join(process.cwd(), ".github", "workflows");
+    await fs2.mkdir(workflowsDir, { recursive: true });
+    filePath = path2.join(workflowsDir, "deploy.yml");
+  } else {
+    filePath = path2.join(process.cwd(), ".gitlab-ci.yml");
+  }
+  try {
+    await fs2.writeFile(filePath, pipeline.content, "utf-8");
+    logger.success(`${pipeline.filename} wurde erstellt!`);
+    logger.newline();
+    const { data: secrets } = await apiClient.getPipelineSecrets(projectId, pipelineDetails.pipelineType);
+    if (secrets && secrets.length > 0) {
+      logger.header("Erforderliche CI/CD Secrets");
+      for (const secret of secrets) {
+        const value = secret.isSecret ? chalk6.dim("(geheim)") : chalk6.cyan(secret.value || "-");
+        console.log(`  ${chalk6.bold(secret.name)}: ${value}`);
+        console.log(`    ${chalk6.dim(secret.description)}`);
+      }
+      logger.newline();
+      logger.info("F\xFCgen Sie diese Werte als CI/CD Secrets/Variables hinzu.");
+      logger.info("Projekt-Token k\xF6nnen Sie in der TurboOps Web-UI erstellen.");
+    }
+  } catch (error2) {
+    logger.error(`Fehler beim Schreiben der Pipeline-Datei: ${error2}`);
   }
-  configService.setProject(projectSlug);
+}
+async function showFinalSummary(project) {
   logger.newline();
-  logger.success("Project initialized!");
+  logger.success("Projekt initialisiert!");
   logger.newline();
-  logger.header("Project Details");
+  logger.header("Projektdetails");
   logger.table({
     Name: project.name,
-    Slug: project.slug,
-    Repository: project.repositoryUrl || "-"
+    Repository: project.repositoryUrl || "-",
+    Slug: project.slug
   });
   const { data: environments } = await apiClient.getEnvironments(project.id);
   const envList = environments && environments.length > 0 ? environments.map((env) => ({
-    slug: env.slug,
     name: env.name,
+    slug: env.slug,
     type: env.type
   })) : [];
   addJsonData({
+    environments: envList,
     initialized: true,
     project: {
       name: project.name,
-      slug: project.slug,
-      repositoryUrl: project.repositoryUrl || null
-    },
-    environments: envList
+      repositoryUrl: project.repositoryUrl || null,
+      slug: project.slug
+    }
   });
   if (environments && environments.length > 0) {
     logger.newline();
-    logger.header("Available Environments");
+    logger.header("Verf\xFCgbare Stages");
     for (const env of environments) {
       console.log(`  ${chalk6.bold(env.slug)} - ${env.name} (${env.type})`);
     }
   }
   logger.newline();
-  logger.header("Next Steps");
+  logger.header("N\xE4chste Schritte");
   logger.list([
-    "Run `turbo status` to see all environments",
-    "Run `turbo deploy <environment>` to deploy",
-    "Run `turbo logs <environment>` to view logs"
+    "F\xFChren Sie `turbo status` aus, um alle Stages zu sehen",
+    "F\xFChren Sie `turbo deploy <stage>` aus, um zu deployen",
+    "F\xFChren Sie `turbo logs <stage>` aus, um Logs anzuzeigen"
   ]);
-});
+}
 
 // src/commands/logs.ts
 import { Command as Command6 } from "commander";
@@ -1439,7 +2040,7 @@ function getLevelColor(level) {
 var VERSION = getCurrentVersion();
 var shouldCheckUpdate = true;
 var program = new Command7();
-program.name("turbo").description("TurboCLI - Command line interface for TurboOps deployments").version(VERSION, "-v, --version", "Show version number").option("--project <slug>", "Override project slug").option("--token <token>", "Override API token").option("--api <url>", "Override API URL").option("--json", "Output as JSON").option("--quiet", "Only show errors").option("--verbose", "Show debug output").option("--no-update-check", "Skip version check");
+program.name("turbo").description("TurboCLI - Command line interface for TurboOps deployments").version(VERSION, "-v, --version", "Show version number").option("--project <slug>", "Override project slug").option("--token <token>", "Override API token").option("--json", "Output as JSON").option("--quiet", "Only show errors").option("--verbose", "Show debug output").option("--no-update-check", "Skip version check");
 program.hook("preAction", (thisCommand) => {
   const opts = thisCommand.opts();
   clearJsonData();
@@ -1456,9 +2057,6 @@ program.hook("preAction", (thisCommand) => {
   if (opts.token) {
     configService.setToken(opts.token);
   }
-  if (opts.api) {
-    configService.setApiUrl(opts.api);
-  }
   if (opts.verbose) {
     process.env.DEBUG = "true";
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turboops/cli",
-  "version": "1.0.0-dev.579",
+  "version": "1.0.0-dev.582",
   "description": "TurboCLI - Command line interface for TurboOps deployments",
   "author": "lenne.tech GmbH",
   "license": "MIT",
@@ -26,6 +26,7 @@
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "conf": "^13.0.1",
+    "open": "^10.1.0",
     "ora": "^8.0.1",
     "prompts": "^2.4.2",
     "socket.io-client": "^4.7.0"